package v2

import (
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/invoker"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/services/dws/v2/model"
)

type AddQueueUserListInvoker struct {
	*invoker.BaseInvoker
}

func (i *AddQueueUserListInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *AddQueueUserListInvoker) Invoke() (*model.AddQueueUserListResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.AddQueueUserListResponse), nil
	}
}

type AddWorkloadPlanStageInvoker struct {
	*invoker.BaseInvoker
}

func (i *AddWorkloadPlanStageInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *AddWorkloadPlanStageInvoker) Invoke() (*model.AddWorkloadPlanStageResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.AddWorkloadPlanStageResponse), nil
	}
}

type AddWorkloadQueueInvoker struct {
	*invoker.BaseInvoker
}

func (i *AddWorkloadQueueInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *AddWorkloadQueueInvoker) Invoke() (*model.AddWorkloadQueueResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.AddWorkloadQueueResponse), nil
	}
}

type AddWorkloadRuleInvoker struct {
	*invoker.BaseInvoker
}

func (i *AddWorkloadRuleInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *AddWorkloadRuleInvoker) Invoke() (*model.AddWorkloadRuleResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.AddWorkloadRuleResponse), nil
	}
}

type AssociateEipInvoker struct {
	*invoker.BaseInvoker
}

func (i *AssociateEipInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *AssociateEipInvoker) Invoke() (*model.AssociateEipResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.AssociateEipResponse), nil
	}
}

type AssociateElbInvoker struct {
	*invoker.BaseInvoker
}

func (i *AssociateElbInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *AssociateElbInvoker) Invoke() (*model.AssociateElbResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.AssociateElbResponse), nil
	}
}

type BatchCreateClusterCnInvoker struct {
	*invoker.BaseInvoker
}

func (i *BatchCreateClusterCnInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *BatchCreateClusterCnInvoker) Invoke() (*model.BatchCreateClusterCnResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.BatchCreateClusterCnResponse), nil
	}
}

type BatchCreateResourceTagInvoker struct {
	*invoker.BaseInvoker
}

func (i *BatchCreateResourceTagInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *BatchCreateResourceTagInvoker) Invoke() (*model.BatchCreateResourceTagResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.BatchCreateResourceTagResponse), nil
	}
}

type BatchDeleteClusterCnInvoker struct {
	*invoker.BaseInvoker
}

func (i *BatchDeleteClusterCnInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *BatchDeleteClusterCnInvoker) Invoke() (*model.BatchDeleteClusterCnResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.BatchDeleteClusterCnResponse), nil
	}
}

type BatchDeleteResourceTagInvoker struct {
	*invoker.BaseInvoker
}

func (i *BatchDeleteResourceTagInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *BatchDeleteResourceTagInvoker) Invoke() (*model.BatchDeleteResourceTagResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.BatchDeleteResourceTagResponse), nil
	}
}

type CancelReadonlyClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *CancelReadonlyClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CancelReadonlyClusterInvoker) Invoke() (*model.CancelReadonlyClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CancelReadonlyClusterResponse), nil
	}
}

type ChangeSecurityGroupInvoker struct {
	*invoker.BaseInvoker
}

func (i *ChangeSecurityGroupInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ChangeSecurityGroupInvoker) Invoke() (*model.ChangeSecurityGroupResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ChangeSecurityGroupResponse), nil
	}
}

type CheckClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *CheckClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CheckClusterInvoker) Invoke() (*model.CheckClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CheckClusterResponse), nil
	}
}

type CheckClusterShrinkInvoker struct {
	*invoker.BaseInvoker
}

func (i *CheckClusterShrinkInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CheckClusterShrinkInvoker) Invoke() (*model.CheckClusterShrinkResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CheckClusterShrinkResponse), nil
	}
}

type CheckDisasterNameInvoker struct {
	*invoker.BaseInvoker
}

func (i *CheckDisasterNameInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CheckDisasterNameInvoker) Invoke() (*model.CheckDisasterNameResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CheckDisasterNameResponse), nil
	}
}

type CheckGrowClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *CheckGrowClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CheckGrowClusterInvoker) Invoke() (*model.CheckGrowClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CheckGrowClusterResponse), nil
	}
}

type CheckTableRestoreInvoker struct {
	*invoker.BaseInvoker
}

func (i *CheckTableRestoreInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CheckTableRestoreInvoker) Invoke() (*model.CheckTableRestoreResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CheckTableRestoreResponse), nil
	}
}

type ConvertToLogicalClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *ConvertToLogicalClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ConvertToLogicalClusterInvoker) Invoke() (*model.ConvertToLogicalClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ConvertToLogicalClusterResponse), nil
	}
}

type CopySnapshotInvoker struct {
	*invoker.BaseInvoker
}

func (i *CopySnapshotInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CopySnapshotInvoker) Invoke() (*model.CopySnapshotResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CopySnapshotResponse), nil
	}
}

type CreateAlarmSubInvoker struct {
	*invoker.BaseInvoker
}

func (i *CreateAlarmSubInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CreateAlarmSubInvoker) Invoke() (*model.CreateAlarmSubResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CreateAlarmSubResponse), nil
	}
}

type CreateClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *CreateClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CreateClusterInvoker) Invoke() (*model.CreateClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CreateClusterResponse), nil
	}
}

type CreateClusterDnsInvoker struct {
	*invoker.BaseInvoker
}

func (i *CreateClusterDnsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CreateClusterDnsInvoker) Invoke() (*model.CreateClusterDnsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CreateClusterDnsResponse), nil
	}
}

type CreateClusterV2Invoker struct {
	*invoker.BaseInvoker
}

func (i *CreateClusterV2Invoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CreateClusterV2Invoker) Invoke() (*model.CreateClusterV2Response, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CreateClusterV2Response), nil
	}
}

type CreateClusterWorkloadInvoker struct {
	*invoker.BaseInvoker
}

func (i *CreateClusterWorkloadInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CreateClusterWorkloadInvoker) Invoke() (*model.CreateClusterWorkloadResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CreateClusterWorkloadResponse), nil
	}
}

type CreateDataSourceInvoker struct {
	*invoker.BaseInvoker
}

func (i *CreateDataSourceInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CreateDataSourceInvoker) Invoke() (*model.CreateDataSourceResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CreateDataSourceResponse), nil
	}
}

type CreateDatabaseUserInvoker struct {
	*invoker.BaseInvoker
}

func (i *CreateDatabaseUserInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CreateDatabaseUserInvoker) Invoke() (*model.CreateDatabaseUserResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CreateDatabaseUserResponse), nil
	}
}

type CreateDisasterRecoveryInvoker struct {
	*invoker.BaseInvoker
}

func (i *CreateDisasterRecoveryInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CreateDisasterRecoveryInvoker) Invoke() (*model.CreateDisasterRecoveryResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CreateDisasterRecoveryResponse), nil
	}
}

type CreateEventSubInvoker struct {
	*invoker.BaseInvoker
}

func (i *CreateEventSubInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CreateEventSubInvoker) Invoke() (*model.CreateEventSubResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CreateEventSubResponse), nil
	}
}

type CreateLogicalClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *CreateLogicalClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CreateLogicalClusterInvoker) Invoke() (*model.CreateLogicalClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CreateLogicalClusterResponse), nil
	}
}

type CreateLogicalClusterPlanInvoker struct {
	*invoker.BaseInvoker
}

func (i *CreateLogicalClusterPlanInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CreateLogicalClusterPlanInvoker) Invoke() (*model.CreateLogicalClusterPlanResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CreateLogicalClusterPlanResponse), nil
	}
}

type CreateSnapshotInvoker struct {
	*invoker.BaseInvoker
}

func (i *CreateSnapshotInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CreateSnapshotInvoker) Invoke() (*model.CreateSnapshotResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CreateSnapshotResponse), nil
	}
}

type CreateSnapshotPolicyInvoker struct {
	*invoker.BaseInvoker
}

func (i *CreateSnapshotPolicyInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CreateSnapshotPolicyInvoker) Invoke() (*model.CreateSnapshotPolicyResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CreateSnapshotPolicyResponse), nil
	}
}

type CreateWorkloadPlanInvoker struct {
	*invoker.BaseInvoker
}

func (i *CreateWorkloadPlanInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *CreateWorkloadPlanInvoker) Invoke() (*model.CreateWorkloadPlanResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.CreateWorkloadPlanResponse), nil
	}
}

type DeleteAlarmSubInvoker struct {
	*invoker.BaseInvoker
}

func (i *DeleteAlarmSubInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DeleteAlarmSubInvoker) Invoke() (*model.DeleteAlarmSubResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DeleteAlarmSubResponse), nil
	}
}

type DeleteClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *DeleteClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DeleteClusterInvoker) Invoke() (*model.DeleteClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DeleteClusterResponse), nil
	}
}

type DeleteClusterDnsInvoker struct {
	*invoker.BaseInvoker
}

func (i *DeleteClusterDnsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DeleteClusterDnsInvoker) Invoke() (*model.DeleteClusterDnsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DeleteClusterDnsResponse), nil
	}
}

type DeleteClusterNodesInvoker struct {
	*invoker.BaseInvoker
}

func (i *DeleteClusterNodesInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DeleteClusterNodesInvoker) Invoke() (*model.DeleteClusterNodesResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DeleteClusterNodesResponse), nil
	}
}

type DeleteDataSourceInvoker struct {
	*invoker.BaseInvoker
}

func (i *DeleteDataSourceInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DeleteDataSourceInvoker) Invoke() (*model.DeleteDataSourceResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DeleteDataSourceResponse), nil
	}
}

type DeleteDatabaseUserInvoker struct {
	*invoker.BaseInvoker
}

func (i *DeleteDatabaseUserInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DeleteDatabaseUserInvoker) Invoke() (*model.DeleteDatabaseUserResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DeleteDatabaseUserResponse), nil
	}
}

type DeleteDisasterRecoveryInvoker struct {
	*invoker.BaseInvoker
}

func (i *DeleteDisasterRecoveryInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DeleteDisasterRecoveryInvoker) Invoke() (*model.DeleteDisasterRecoveryResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DeleteDisasterRecoveryResponse), nil
	}
}

type DeleteDwsClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *DeleteDwsClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DeleteDwsClusterInvoker) Invoke() (*model.DeleteDwsClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DeleteDwsClusterResponse), nil
	}
}

type DeleteEventSubInvoker struct {
	*invoker.BaseInvoker
}

func (i *DeleteEventSubInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DeleteEventSubInvoker) Invoke() (*model.DeleteEventSubResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DeleteEventSubResponse), nil
	}
}

type DeleteLogicalClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *DeleteLogicalClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DeleteLogicalClusterInvoker) Invoke() (*model.DeleteLogicalClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DeleteLogicalClusterResponse), nil
	}
}

type DeleteLogicalClusterPlanInvoker struct {
	*invoker.BaseInvoker
}

func (i *DeleteLogicalClusterPlanInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DeleteLogicalClusterPlanInvoker) Invoke() (*model.DeleteLogicalClusterPlanResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DeleteLogicalClusterPlanResponse), nil
	}
}

type DeleteQueueUserListInvoker struct {
	*invoker.BaseInvoker
}

func (i *DeleteQueueUserListInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DeleteQueueUserListInvoker) Invoke() (*model.DeleteQueueUserListResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DeleteQueueUserListResponse), nil
	}
}

type DeleteSnapshotInvoker struct {
	*invoker.BaseInvoker
}

func (i *DeleteSnapshotInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DeleteSnapshotInvoker) Invoke() (*model.DeleteSnapshotResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DeleteSnapshotResponse), nil
	}
}

type DeleteSnapshotPolicyInvoker struct {
	*invoker.BaseInvoker
}

func (i *DeleteSnapshotPolicyInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DeleteSnapshotPolicyInvoker) Invoke() (*model.DeleteSnapshotPolicyResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DeleteSnapshotPolicyResponse), nil
	}
}

type DeleteWorkloadPlanInvoker struct {
	*invoker.BaseInvoker
}

func (i *DeleteWorkloadPlanInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DeleteWorkloadPlanInvoker) Invoke() (*model.DeleteWorkloadPlanResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DeleteWorkloadPlanResponse), nil
	}
}

type DeleteWorkloadPlanStageInvoker struct {
	*invoker.BaseInvoker
}

func (i *DeleteWorkloadPlanStageInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DeleteWorkloadPlanStageInvoker) Invoke() (*model.DeleteWorkloadPlanStageResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DeleteWorkloadPlanStageResponse), nil
	}
}

type DeleteWorkloadQueueInvoker struct {
	*invoker.BaseInvoker
}

func (i *DeleteWorkloadQueueInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DeleteWorkloadQueueInvoker) Invoke() (*model.DeleteWorkloadQueueResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DeleteWorkloadQueueResponse), nil
	}
}

type DeleteWorkloadRuleInvoker struct {
	*invoker.BaseInvoker
}

func (i *DeleteWorkloadRuleInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DeleteWorkloadRuleInvoker) Invoke() (*model.DeleteWorkloadRuleResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DeleteWorkloadRuleResponse), nil
	}
}

type DisableLogicalClusterPlanInvoker struct {
	*invoker.BaseInvoker
}

func (i *DisableLogicalClusterPlanInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DisableLogicalClusterPlanInvoker) Invoke() (*model.DisableLogicalClusterPlanResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DisableLogicalClusterPlanResponse), nil
	}
}

type DisableLtsLogsInvoker struct {
	*invoker.BaseInvoker
}

func (i *DisableLtsLogsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DisableLtsLogsInvoker) Invoke() (*model.DisableLtsLogsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DisableLtsLogsResponse), nil
	}
}

type DisassociateEipInvoker struct {
	*invoker.BaseInvoker
}

func (i *DisassociateEipInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DisassociateEipInvoker) Invoke() (*model.DisassociateEipResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DisassociateEipResponse), nil
	}
}

type DisassociateElbInvoker struct {
	*invoker.BaseInvoker
}

func (i *DisassociateElbInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *DisassociateElbInvoker) Invoke() (*model.DisassociateElbResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.DisassociateElbResponse), nil
	}
}

type EnableLogicalClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *EnableLogicalClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *EnableLogicalClusterInvoker) Invoke() (*model.EnableLogicalClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.EnableLogicalClusterResponse), nil
	}
}

type EnableLogicalClusterPlanInvoker struct {
	*invoker.BaseInvoker
}

func (i *EnableLogicalClusterPlanInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *EnableLogicalClusterPlanInvoker) Invoke() (*model.EnableLogicalClusterPlanResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.EnableLogicalClusterPlanResponse), nil
	}
}

type EnableLtsLogsInvoker struct {
	*invoker.BaseInvoker
}

func (i *EnableLtsLogsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *EnableLtsLogsInvoker) Invoke() (*model.EnableLtsLogsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.EnableLtsLogsResponse), nil
	}
}

type EncryptClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *EncryptClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *EncryptClusterInvoker) Invoke() (*model.EncryptClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.EncryptClusterResponse), nil
	}
}

type ExecuteClusterUpgradeActionInvoker struct {
	*invoker.BaseInvoker
}

func (i *ExecuteClusterUpgradeActionInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ExecuteClusterUpgradeActionInvoker) Invoke() (*model.ExecuteClusterUpgradeActionResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ExecuteClusterUpgradeActionResponse), nil
	}
}

type ExecuteDatabaseOmUserActionInvoker struct {
	*invoker.BaseInvoker
}

func (i *ExecuteDatabaseOmUserActionInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ExecuteDatabaseOmUserActionInvoker) Invoke() (*model.ExecuteDatabaseOmUserActionResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ExecuteDatabaseOmUserActionResponse), nil
	}
}

type ExecuteFlavorChangeInvoker struct {
	*invoker.BaseInvoker
}

func (i *ExecuteFlavorChangeInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ExecuteFlavorChangeInvoker) Invoke() (*model.ExecuteFlavorChangeResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ExecuteFlavorChangeResponse), nil
	}
}

type ExecuteRedistributionClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *ExecuteRedistributionClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ExecuteRedistributionClusterInvoker) Invoke() (*model.ExecuteRedistributionClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ExecuteRedistributionClusterResponse), nil
	}
}

type ExpandInstanceStorageInvoker struct {
	*invoker.BaseInvoker
}

func (i *ExpandInstanceStorageInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ExpandInstanceStorageInvoker) Invoke() (*model.ExpandInstanceStorageResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ExpandInstanceStorageResponse), nil
	}
}

type ExportDatabaseUsersInvoker struct {
	*invoker.BaseInvoker
}

func (i *ExportDatabaseUsersInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ExportDatabaseUsersInvoker) Invoke() (*model.ExportDatabaseUsersResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ExportDatabaseUsersResponse), nil
	}
}

type ExportUserAuthorityInvoker struct {
	*invoker.BaseInvoker
}

func (i *ExportUserAuthorityInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ExportUserAuthorityInvoker) Invoke() (*model.ExportUserAuthorityResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ExportUserAuthorityResponse), nil
	}
}

type ListAlarmConfigsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListAlarmConfigsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListAlarmConfigsInvoker) Invoke() (*model.ListAlarmConfigsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListAlarmConfigsResponse), nil
	}
}

type ListAlarmDetailInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListAlarmDetailInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListAlarmDetailInvoker) Invoke() (*model.ListAlarmDetailResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListAlarmDetailResponse), nil
	}
}

type ListAlarmStatisticInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListAlarmStatisticInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListAlarmStatisticInvoker) Invoke() (*model.ListAlarmStatisticResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListAlarmStatisticResponse), nil
	}
}

type ListAlarmSubsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListAlarmSubsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListAlarmSubsInvoker) Invoke() (*model.ListAlarmSubsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListAlarmSubsResponse), nil
	}
}

type ListAuditLogInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListAuditLogInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListAuditLogInvoker) Invoke() (*model.ListAuditLogResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListAuditLogResponse), nil
	}
}

type ListAvailabilityZonesInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListAvailabilityZonesInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListAvailabilityZonesInvoker) Invoke() (*model.ListAvailabilityZonesResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListAvailabilityZonesResponse), nil
	}
}

type ListAvailableDisasterClustersInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListAvailableDisasterClustersInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListAvailableDisasterClustersInvoker) Invoke() (*model.ListAvailableDisasterClustersResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListAvailableDisasterClustersResponse), nil
	}
}

type ListClusterActionsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListClusterActionsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListClusterActionsInvoker) Invoke() (*model.ListClusterActionsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListClusterActionsResponse), nil
	}
}

type ListClusterCnInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListClusterCnInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListClusterCnInvoker) Invoke() (*model.ListClusterCnResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListClusterCnResponse), nil
	}
}

type ListClusterConfigurationsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListClusterConfigurationsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListClusterConfigurationsInvoker) Invoke() (*model.ListClusterConfigurationsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListClusterConfigurationsResponse), nil
	}
}

type ListClusterConfigurationsParameterInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListClusterConfigurationsParameterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListClusterConfigurationsParameterInvoker) Invoke() (*model.ListClusterConfigurationsParameterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListClusterConfigurationsParameterResponse), nil
	}
}

type ListClusterDetailsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListClusterDetailsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListClusterDetailsInvoker) Invoke() (*model.ListClusterDetailsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListClusterDetailsResponse), nil
	}
}

type ListClusterEndpointsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListClusterEndpointsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListClusterEndpointsInvoker) Invoke() (*model.ListClusterEndpointsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListClusterEndpointsResponse), nil
	}
}

type ListClusterNodesInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListClusterNodesInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListClusterNodesInvoker) Invoke() (*model.ListClusterNodesResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListClusterNodesResponse), nil
	}
}

type ListClusterScaleInNumbersInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListClusterScaleInNumbersInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListClusterScaleInNumbersInvoker) Invoke() (*model.ListClusterScaleInNumbersResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListClusterScaleInNumbersResponse), nil
	}
}

type ListClusterSnapshotsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListClusterSnapshotsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListClusterSnapshotsInvoker) Invoke() (*model.ListClusterSnapshotsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListClusterSnapshotsResponse), nil
	}
}

type ListClusterTagsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListClusterTagsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListClusterTagsInvoker) Invoke() (*model.ListClusterTagsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListClusterTagsResponse), nil
	}
}

type ListClusterWorkloadInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListClusterWorkloadInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListClusterWorkloadInvoker) Invoke() (*model.ListClusterWorkloadResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListClusterWorkloadResponse), nil
	}
}

type ListClustersInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListClustersInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListClustersInvoker) Invoke() (*model.ListClustersResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListClustersResponse), nil
	}
}

type ListConfigurationsAuditRecordsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListConfigurationsAuditRecordsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListConfigurationsAuditRecordsInvoker) Invoke() (*model.ListConfigurationsAuditRecordsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListConfigurationsAuditRecordsResponse), nil
	}
}

type ListDataSourceInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListDataSourceInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListDataSourceInvoker) Invoke() (*model.ListDataSourceResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListDataSourceResponse), nil
	}
}

type ListDatabaseObjectsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListDatabaseObjectsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListDatabaseObjectsInvoker) Invoke() (*model.ListDatabaseObjectsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListDatabaseObjectsResponse), nil
	}
}

type ListDatabaseUserAuthoritiesInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListDatabaseUserAuthoritiesInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListDatabaseUserAuthoritiesInvoker) Invoke() (*model.ListDatabaseUserAuthoritiesResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListDatabaseUserAuthoritiesResponse), nil
	}
}

type ListDatabaseUsersInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListDatabaseUsersInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListDatabaseUsersInvoker) Invoke() (*model.ListDatabaseUsersResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListDatabaseUsersResponse), nil
	}
}

type ListDisasterRecoverInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListDisasterRecoverInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListDisasterRecoverInvoker) Invoke() (*model.ListDisasterRecoverResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListDisasterRecoverResponse), nil
	}
}

type ListDssPoolsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListDssPoolsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListDssPoolsInvoker) Invoke() (*model.ListDssPoolsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListDssPoolsResponse), nil
	}
}

type ListElbsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListElbsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListElbsInvoker) Invoke() (*model.ListElbsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListElbsResponse), nil
	}
}

type ListEventSpecsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListEventSpecsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListEventSpecsInvoker) Invoke() (*model.ListEventSpecsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListEventSpecsResponse), nil
	}
}

type ListEventSubsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListEventSubsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListEventSubsInvoker) Invoke() (*model.ListEventSubsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListEventSubsResponse), nil
	}
}

type ListEventsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListEventsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListEventsInvoker) Invoke() (*model.ListEventsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListEventsResponse), nil
	}
}

type ListHostDiskInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListHostDiskInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListHostDiskInvoker) Invoke() (*model.ListHostDiskResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListHostDiskResponse), nil
	}
}

type ListHostNetInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListHostNetInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListHostNetInvoker) Invoke() (*model.ListHostNetResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListHostNetResponse), nil
	}
}

type ListHostOverviewInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListHostOverviewInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListHostOverviewInvoker) Invoke() (*model.ListHostOverviewResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListHostOverviewResponse), nil
	}
}

type ListJobDetailsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListJobDetailsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListJobDetailsInvoker) Invoke() (*model.ListJobDetailsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListJobDetailsResponse), nil
	}
}

type ListLogicalClusterPlansInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListLogicalClusterPlansInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListLogicalClusterPlansInvoker) Invoke() (*model.ListLogicalClusterPlansResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListLogicalClusterPlansResponse), nil
	}
}

type ListLogicalClusterRingsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListLogicalClusterRingsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListLogicalClusterRingsInvoker) Invoke() (*model.ListLogicalClusterRingsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListLogicalClusterRingsResponse), nil
	}
}

type ListLogicalClusterTasksInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListLogicalClusterTasksInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListLogicalClusterTasksInvoker) Invoke() (*model.ListLogicalClusterTasksResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListLogicalClusterTasksResponse), nil
	}
}

type ListLogicalClusterVolumesInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListLogicalClusterVolumesInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListLogicalClusterVolumesInvoker) Invoke() (*model.ListLogicalClusterVolumesResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListLogicalClusterVolumesResponse), nil
	}
}

type ListLogicalClustersInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListLogicalClustersInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListLogicalClustersInvoker) Invoke() (*model.ListLogicalClustersResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListLogicalClustersResponse), nil
	}
}

type ListLtsLogsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListLtsLogsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListLtsLogsInvoker) Invoke() (*model.ListLtsLogsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListLtsLogsResponse), nil
	}
}

type ListMetricsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListMetricsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListMetricsInvoker) Invoke() (*model.ListMetricsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListMetricsResponse), nil
	}
}

type ListMetricsDataInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListMetricsDataInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListMetricsDataInvoker) Invoke() (*model.ListMetricsDataResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListMetricsDataResponse), nil
	}
}

type ListMonitorIndicatorDataInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListMonitorIndicatorDataInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListMonitorIndicatorDataInvoker) Invoke() (*model.ListMonitorIndicatorDataResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListMonitorIndicatorDataResponse), nil
	}
}

type ListMonitorIndicatorsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListMonitorIndicatorsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListMonitorIndicatorsInvoker) Invoke() (*model.ListMonitorIndicatorsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListMonitorIndicatorsResponse), nil
	}
}

type ListNodeTypesInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListNodeTypesInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListNodeTypesInvoker) Invoke() (*model.ListNodeTypesResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListNodeTypesResponse), nil
	}
}

type ListPlanExecLogsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListPlanExecLogsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListPlanExecLogsInvoker) Invoke() (*model.ListPlanExecLogsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListPlanExecLogsResponse), nil
	}
}

type ListQueriesInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListQueriesInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListQueriesInvoker) Invoke() (*model.ListQueriesResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListQueriesResponse), nil
	}
}

type ListQuotasInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListQuotasInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListQuotasInvoker) Invoke() (*model.ListQuotasResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListQuotasResponse), nil
	}
}

type ListRedistributionSchemaInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListRedistributionSchemaInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListRedistributionSchemaInvoker) Invoke() (*model.ListRedistributionSchemaResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListRedistributionSchemaResponse), nil
	}
}

type ListSchemasInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListSchemasInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListSchemasInvoker) Invoke() (*model.ListSchemasResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListSchemasResponse), nil
	}
}

type ListSnapshotDetailsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListSnapshotDetailsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListSnapshotDetailsInvoker) Invoke() (*model.ListSnapshotDetailsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListSnapshotDetailsResponse), nil
	}
}

type ListSnapshotFlavorInfoInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListSnapshotFlavorInfoInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListSnapshotFlavorInfoInvoker) Invoke() (*model.ListSnapshotFlavorInfoResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListSnapshotFlavorInfoResponse), nil
	}
}

type ListSnapshotPolicyInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListSnapshotPolicyInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListSnapshotPolicyInvoker) Invoke() (*model.ListSnapshotPolicyResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListSnapshotPolicyResponse), nil
	}
}

type ListSnapshotStatisticsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListSnapshotStatisticsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListSnapshotStatisticsInvoker) Invoke() (*model.ListSnapshotStatisticsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListSnapshotStatisticsResponse), nil
	}
}

type ListSnapshotsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListSnapshotsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListSnapshotsInvoker) Invoke() (*model.ListSnapshotsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListSnapshotsResponse), nil
	}
}

type ListStatisticsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListStatisticsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListStatisticsInvoker) Invoke() (*model.ListStatisticsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListStatisticsResponse), nil
	}
}

type ListSyncRecordsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListSyncRecordsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListSyncRecordsInvoker) Invoke() (*model.ListSyncRecordsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListSyncRecordsResponse), nil
	}
}

type ListTablesStatisticInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListTablesStatisticInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListTablesStatisticInvoker) Invoke() (*model.ListTablesStatisticResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListTablesStatisticResponse), nil
	}
}

type ListTagsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListTagsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListTagsInvoker) Invoke() (*model.ListTagsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListTagsResponse), nil
	}
}

type ListTagsForResourceInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListTagsForResourceInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListTagsForResourceInvoker) Invoke() (*model.ListTagsForResourceResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListTagsForResourceResponse), nil
	}
}

type ListTargetFlavorsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListTargetFlavorsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListTargetFlavorsInvoker) Invoke() (*model.ListTargetFlavorsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListTargetFlavorsResponse), nil
	}
}

type ListTopoRingsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListTopoRingsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListTopoRingsInvoker) Invoke() (*model.ListTopoRingsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListTopoRingsResponse), nil
	}
}

type ListUpdatableVersionInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListUpdatableVersionInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListUpdatableVersionInvoker) Invoke() (*model.ListUpdatableVersionResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListUpdatableVersionResponse), nil
	}
}

type ListUpdateRecordInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListUpdateRecordInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListUpdateRecordInvoker) Invoke() (*model.ListUpdateRecordResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListUpdateRecordResponse), nil
	}
}

type ListWorkloadPlansInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListWorkloadPlansInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListWorkloadPlansInvoker) Invoke() (*model.ListWorkloadPlansResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListWorkloadPlansResponse), nil
	}
}

type ListWorkloadQueueInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListWorkloadQueueInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListWorkloadQueueInvoker) Invoke() (*model.ListWorkloadQueueResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListWorkloadQueueResponse), nil
	}
}

type ListWorkloadQueueUsersInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListWorkloadQueueUsersInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListWorkloadQueueUsersInvoker) Invoke() (*model.ListWorkloadQueueUsersResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListWorkloadQueueUsersResponse), nil
	}
}

type ListWorkloadRulesInvoker struct {
	*invoker.BaseInvoker
}

func (i *ListWorkloadRulesInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ListWorkloadRulesInvoker) Invoke() (*model.ListWorkloadRulesResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ListWorkloadRulesResponse), nil
	}
}

type ModifyClusterNameInvoker struct {
	*invoker.BaseInvoker
}

func (i *ModifyClusterNameInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ModifyClusterNameInvoker) Invoke() (*model.ModifyClusterNameResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ModifyClusterNameResponse), nil
	}
}

type ModifyClusterTimezoneInvoker struct {
	*invoker.BaseInvoker
}

func (i *ModifyClusterTimezoneInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ModifyClusterTimezoneInvoker) Invoke() (*model.ModifyClusterTimezoneResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ModifyClusterTimezoneResponse), nil
	}
}

type PauseDisasterRecoveryInvoker struct {
	*invoker.BaseInvoker
}

func (i *PauseDisasterRecoveryInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *PauseDisasterRecoveryInvoker) Invoke() (*model.PauseDisasterRecoveryResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.PauseDisasterRecoveryResponse), nil
	}
}

type ResetPasswordInvoker struct {
	*invoker.BaseInvoker
}

func (i *ResetPasswordInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ResetPasswordInvoker) Invoke() (*model.ResetPasswordResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ResetPasswordResponse), nil
	}
}

type ResizeClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *ResizeClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ResizeClusterInvoker) Invoke() (*model.ResizeClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ResizeClusterResponse), nil
	}
}

type ResizeClusterWithExistedNodesInvoker struct {
	*invoker.BaseInvoker
}

func (i *ResizeClusterWithExistedNodesInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ResizeClusterWithExistedNodesInvoker) Invoke() (*model.ResizeClusterWithExistedNodesResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ResizeClusterWithExistedNodesResponse), nil
	}
}

type ResizePreparationInvoker struct {
	*invoker.BaseInvoker
}

func (i *ResizePreparationInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ResizePreparationInvoker) Invoke() (*model.ResizePreparationResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ResizePreparationResponse), nil
	}
}

type RestartClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *RestartClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *RestartClusterInvoker) Invoke() (*model.RestartClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.RestartClusterResponse), nil
	}
}

type RestartLogicalClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *RestartLogicalClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *RestartLogicalClusterInvoker) Invoke() (*model.RestartLogicalClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.RestartLogicalClusterResponse), nil
	}
}

type RestoreClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *RestoreClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *RestoreClusterInvoker) Invoke() (*model.RestoreClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.RestoreClusterResponse), nil
	}
}

type RestoreDisasterInvoker struct {
	*invoker.BaseInvoker
}

func (i *RestoreDisasterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *RestoreDisasterInvoker) Invoke() (*model.RestoreDisasterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.RestoreDisasterResponse), nil
	}
}

type RestoreRedistributionInvoker struct {
	*invoker.BaseInvoker
}

func (i *RestoreRedistributionInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *RestoreRedistributionInvoker) Invoke() (*model.RestoreRedistributionResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.RestoreRedistributionResponse), nil
	}
}

type RestoreTableInvoker struct {
	*invoker.BaseInvoker
}

func (i *RestoreTableInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *RestoreTableInvoker) Invoke() (*model.RestoreTableResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.RestoreTableResponse), nil
	}
}

type RotateKeyInvoker struct {
	*invoker.BaseInvoker
}

func (i *RotateKeyInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *RotateKeyInvoker) Invoke() (*model.RotateKeyResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.RotateKeyResponse), nil
	}
}

type SaveClusterDescriptionInfoInvoker struct {
	*invoker.BaseInvoker
}

func (i *SaveClusterDescriptionInfoInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *SaveClusterDescriptionInfoInvoker) Invoke() (*model.SaveClusterDescriptionInfoResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.SaveClusterDescriptionInfoResponse), nil
	}
}

type SetRedistributionPriorityInvoker struct {
	*invoker.BaseInvoker
}

func (i *SetRedistributionPriorityInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *SetRedistributionPriorityInvoker) Invoke() (*model.SetRedistributionPriorityResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.SetRedistributionPriorityResponse), nil
	}
}

type ShowClusterEncryptInfoInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShowClusterEncryptInfoInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShowClusterEncryptInfoInvoker) Invoke() (*model.ShowClusterEncryptInfoResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShowClusterEncryptInfoResponse), nil
	}
}

type ShowClusterFlavorInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShowClusterFlavorInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShowClusterFlavorInvoker) Invoke() (*model.ShowClusterFlavorResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShowClusterFlavorResponse), nil
	}
}

type ShowClusterRedistributionInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShowClusterRedistributionInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShowClusterRedistributionInvoker) Invoke() (*model.ShowClusterRedistributionResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShowClusterRedistributionResponse), nil
	}
}

type ShowClusterStorageExpandRangeInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShowClusterStorageExpandRangeInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShowClusterStorageExpandRangeInvoker) Invoke() (*model.ShowClusterStorageExpandRangeResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShowClusterStorageExpandRangeResponse), nil
	}
}

type ShowClusterVolumeInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShowClusterVolumeInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShowClusterVolumeInvoker) Invoke() (*model.ShowClusterVolumeResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShowClusterVolumeResponse), nil
	}
}

type ShowClustersInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShowClustersInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShowClustersInvoker) Invoke() (*model.ShowClustersResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShowClustersResponse), nil
	}
}

type ShowDatabaseAuthorityInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShowDatabaseAuthorityInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShowDatabaseAuthorityInvoker) Invoke() (*model.ShowDatabaseAuthorityResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShowDatabaseAuthorityResponse), nil
	}
}

type ShowDatabaseOmUserStatusInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShowDatabaseOmUserStatusInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShowDatabaseOmUserStatusInvoker) Invoke() (*model.ShowDatabaseOmUserStatusResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShowDatabaseOmUserStatusResponse), nil
	}
}

type ShowDatabaseUserInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShowDatabaseUserInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShowDatabaseUserInvoker) Invoke() (*model.ShowDatabaseUserResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShowDatabaseUserResponse), nil
	}
}

type ShowDisasterDetailInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShowDisasterDetailInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShowDisasterDetailInvoker) Invoke() (*model.ShowDisasterDetailResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShowDisasterDetailResponse), nil
	}
}

type ShowDisasterProgressInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShowDisasterProgressInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShowDisasterProgressInvoker) Invoke() (*model.ShowDisasterProgressResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShowDisasterProgressResponse), nil
	}
}

type ShowInstanceInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShowInstanceInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShowInstanceInvoker) Invoke() (*model.ShowInstanceResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShowInstanceResponse), nil
	}
}

type ShowQueryDetailInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShowQueryDetailInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShowQueryDetailInvoker) Invoke() (*model.ShowQueryDetailResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShowQueryDetailResponse), nil
	}
}

type ShowResizePreparationInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShowResizePreparationInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShowResizePreparationInvoker) Invoke() (*model.ShowResizePreparationResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShowResizePreparationResponse), nil
	}
}

type ShowResourceStatisticsInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShowResourceStatisticsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShowResourceStatisticsInvoker) Invoke() (*model.ShowResourceStatisticsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShowResourceStatisticsResponse), nil
	}
}

type ShowWorkloadPlanInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShowWorkloadPlanInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShowWorkloadPlanInvoker) Invoke() (*model.ShowWorkloadPlanResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShowWorkloadPlanResponse), nil
	}
}

type ShowWorkloadPlanStageInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShowWorkloadPlanStageInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShowWorkloadPlanStageInvoker) Invoke() (*model.ShowWorkloadPlanStageResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShowWorkloadPlanStageResponse), nil
	}
}

type ShowWorkloadQueueInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShowWorkloadQueueInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShowWorkloadQueueInvoker) Invoke() (*model.ShowWorkloadQueueResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShowWorkloadQueueResponse), nil
	}
}

type ShrinkClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShrinkClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShrinkClusterInvoker) Invoke() (*model.ShrinkClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShrinkClusterResponse), nil
	}
}

type ShrinkLogicalClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *ShrinkLogicalClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *ShrinkLogicalClusterInvoker) Invoke() (*model.ShrinkLogicalClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.ShrinkLogicalClusterResponse), nil
	}
}

type StartClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *StartClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *StartClusterInvoker) Invoke() (*model.StartClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.StartClusterResponse), nil
	}
}

type StartDisasterRecoveryInvoker struct {
	*invoker.BaseInvoker
}

func (i *StartDisasterRecoveryInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *StartDisasterRecoveryInvoker) Invoke() (*model.StartDisasterRecoveryResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.StartDisasterRecoveryResponse), nil
	}
}

type StartWorkloadPlanInvoker struct {
	*invoker.BaseInvoker
}

func (i *StartWorkloadPlanInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *StartWorkloadPlanInvoker) Invoke() (*model.StartWorkloadPlanResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.StartWorkloadPlanResponse), nil
	}
}

type StopClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *StopClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *StopClusterInvoker) Invoke() (*model.StopClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.StopClusterResponse), nil
	}
}

type StopRedistributionInvoker struct {
	*invoker.BaseInvoker
}

func (i *StopRedistributionInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *StopRedistributionInvoker) Invoke() (*model.StopRedistributionResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.StopRedistributionResponse), nil
	}
}

type StopWorkloadPlanInvoker struct {
	*invoker.BaseInvoker
}

func (i *StopWorkloadPlanInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *StopWorkloadPlanInvoker) Invoke() (*model.StopWorkloadPlanResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.StopWorkloadPlanResponse), nil
	}
}

type SwitchFailoverDisasterInvoker struct {
	*invoker.BaseInvoker
}

func (i *SwitchFailoverDisasterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *SwitchFailoverDisasterInvoker) Invoke() (*model.SwitchFailoverDisasterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.SwitchFailoverDisasterResponse), nil
	}
}

type SwitchOverClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *SwitchOverClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *SwitchOverClusterInvoker) Invoke() (*model.SwitchOverClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.SwitchOverClusterResponse), nil
	}
}

type SwitchPlanStageInvoker struct {
	*invoker.BaseInvoker
}

func (i *SwitchPlanStageInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *SwitchPlanStageInvoker) Invoke() (*model.SwitchPlanStageResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.SwitchPlanStageResponse), nil
	}
}

type SwitchoverDisasterRecoveryInvoker struct {
	*invoker.BaseInvoker
}

func (i *SwitchoverDisasterRecoveryInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *SwitchoverDisasterRecoveryInvoker) Invoke() (*model.SwitchoverDisasterRecoveryResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.SwitchoverDisasterRecoveryResponse), nil
	}
}

type SyncIamUsersInvoker struct {
	*invoker.BaseInvoker
}

func (i *SyncIamUsersInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *SyncIamUsersInvoker) Invoke() (*model.SyncIamUsersResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.SyncIamUsersResponse), nil
	}
}

type UpdateAlarmSubInvoker struct {
	*invoker.BaseInvoker
}

func (i *UpdateAlarmSubInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *UpdateAlarmSubInvoker) Invoke() (*model.UpdateAlarmSubResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.UpdateAlarmSubResponse), nil
	}
}

type UpdateClusterDnsInvoker struct {
	*invoker.BaseInvoker
}

func (i *UpdateClusterDnsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *UpdateClusterDnsInvoker) Invoke() (*model.UpdateClusterDnsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.UpdateClusterDnsResponse), nil
	}
}

type UpdateConfigurationInvoker struct {
	*invoker.BaseInvoker
}

func (i *UpdateConfigurationInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *UpdateConfigurationInvoker) Invoke() (*model.UpdateConfigurationResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.UpdateConfigurationResponse), nil
	}
}

type UpdateDataSourceInvoker struct {
	*invoker.BaseInvoker
}

func (i *UpdateDataSourceInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *UpdateDataSourceInvoker) Invoke() (*model.UpdateDataSourceResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.UpdateDataSourceResponse), nil
	}
}

type UpdateDatabaseAuthorityInvoker struct {
	*invoker.BaseInvoker
}

func (i *UpdateDatabaseAuthorityInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *UpdateDatabaseAuthorityInvoker) Invoke() (*model.UpdateDatabaseAuthorityResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.UpdateDatabaseAuthorityResponse), nil
	}
}

type UpdateDatabaseUserInfoInvoker struct {
	*invoker.BaseInvoker
}

func (i *UpdateDatabaseUserInfoInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *UpdateDatabaseUserInfoInvoker) Invoke() (*model.UpdateDatabaseUserInfoResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.UpdateDatabaseUserInfoResponse), nil
	}
}

type UpdateDisasterInfoInvoker struct {
	*invoker.BaseInvoker
}

func (i *UpdateDisasterInfoInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *UpdateDisasterInfoInvoker) Invoke() (*model.UpdateDisasterInfoResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.UpdateDisasterInfoResponse), nil
	}
}

type UpdateEventSubInvoker struct {
	*invoker.BaseInvoker
}

func (i *UpdateEventSubInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *UpdateEventSubInvoker) Invoke() (*model.UpdateEventSubResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.UpdateEventSubResponse), nil
	}
}

type UpdateLogicalClusterInvoker struct {
	*invoker.BaseInvoker
}

func (i *UpdateLogicalClusterInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *UpdateLogicalClusterInvoker) Invoke() (*model.UpdateLogicalClusterResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.UpdateLogicalClusterResponse), nil
	}
}

type UpdateLogicalClusterPlanInvoker struct {
	*invoker.BaseInvoker
}

func (i *UpdateLogicalClusterPlanInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *UpdateLogicalClusterPlanInvoker) Invoke() (*model.UpdateLogicalClusterPlanResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.UpdateLogicalClusterPlanResponse), nil
	}
}

type UpdateMaintenanceWindowInvoker struct {
	*invoker.BaseInvoker
}

func (i *UpdateMaintenanceWindowInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *UpdateMaintenanceWindowInvoker) Invoke() (*model.UpdateMaintenanceWindowResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.UpdateMaintenanceWindowResponse), nil
	}
}

type UpdateQueueBaseInfoInvoker struct {
	*invoker.BaseInvoker
}

func (i *UpdateQueueBaseInfoInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *UpdateQueueBaseInfoInvoker) Invoke() (*model.UpdateQueueBaseInfoResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.UpdateQueueBaseInfoResponse), nil
	}
}

type UpdateQueueResourcesInvoker struct {
	*invoker.BaseInvoker
}

func (i *UpdateQueueResourcesInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *UpdateQueueResourcesInvoker) Invoke() (*model.UpdateQueueResourcesResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.UpdateQueueResourcesResponse), nil
	}
}

type UpdateRedistributionConfigurationsInvoker struct {
	*invoker.BaseInvoker
}

func (i *UpdateRedistributionConfigurationsInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *UpdateRedistributionConfigurationsInvoker) Invoke() (*model.UpdateRedistributionConfigurationsResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.UpdateRedistributionConfigurationsResponse), nil
	}
}

type UpdateSchemasInvoker struct {
	*invoker.BaseInvoker
}

func (i *UpdateSchemasInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *UpdateSchemasInvoker) Invoke() (*model.UpdateSchemasResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.UpdateSchemasResponse), nil
	}
}

type UpdateWorkloadPlanStageInvoker struct {
	*invoker.BaseInvoker
}

func (i *UpdateWorkloadPlanStageInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *UpdateWorkloadPlanStageInvoker) Invoke() (*model.UpdateWorkloadPlanStageResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.UpdateWorkloadPlanStageResponse), nil
	}
}

type UpdateWorkloadRuleInvoker struct {
	*invoker.BaseInvoker
}

func (i *UpdateWorkloadRuleInvoker) GetBaseInvoker() *invoker.BaseInvoker {
	return i.BaseInvoker
}

func (i *UpdateWorkloadRuleInvoker) Invoke() (*model.UpdateWorkloadRuleResponse, error) {
	if result, err := i.BaseInvoker.Invoke(); err != nil {
		return nil, err
	} else {
		return result.(*model.UpdateWorkloadRuleResponse), nil
	}
}
