diff --git a/Makefile b/Makefile
index 44811fc9a..60362bf9c 100644
--- a/Makefile
+++ b/Makefile
@@ -61,6 +61,7 @@ unit-test:
 	./lock/etcdlock/... \
 	./auth/simple/... \
 	./discovery/helium... \
+	./resource/types/. \
 	./resource/plugins/cpumem/. \
 	./resource/plugins/cpumem/schedule/. \
 	./wal/. \
diff --git a/cluster/calcium/capacity_test.go b/cluster/calcium/capacity_test.go
index d8af43649..a49537a98 100644
--- a/cluster/calcium/capacity_test.go
+++ b/cluster/calcium/capacity_test.go
@@ -8,6 +8,7 @@ import (
 	lockmocks "github.com/projecteru2/core/lock/mocks"
 	resourcemocks "github.com/projecteru2/core/resource/mocks"
 	plugintypes "github.com/projecteru2/core/resource/plugins/types"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	storemocks "github.com/projecteru2/core/store/mocks"
 	"github.com/projecteru2/core/strategy"
 	"github.com/projecteru2/core/types"
@@ -40,7 +41,7 @@ func TestCalculateCapacity(t *testing.T) {
 		Entrypoint: &types.Entrypoint{
 			Name: "entry",
 		},
-		Resources:      types.Resources{},
+		Resources:      resourcetypes.Resources{},
 		DeployStrategy: strategy.Auto,
 		NodeFilter: &types.NodeFilter{
 			Includes: []string{name},
diff --git a/cluster/calcium/create.go b/cluster/calcium/create.go
index 890fe55fc..bfed10a38 100644
--- a/cluster/calcium/create.go
+++ b/cluster/calcium/create.go
@@ -13,6 +13,7 @@ import (
 	enginetypes "github.com/projecteru2/core/engine/types"
 	"github.com/projecteru2/core/log"
 	"github.com/projecteru2/core/metrics"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	"github.com/projecteru2/core/types"
 	"github.com/projecteru2/core/utils"
 	"github.com/projecteru2/core/wal"
@@ -52,9 +53,9 @@ func (c *Calcium) doCreateWorkloads(ctx context.Context, opts *types.DeployOptio
 		deployMap   map[string]int
 		rollbackMap map[string][]int
 		// map[nodename][]Resources
-		engineParamsMap = map[string][]types.Resources{}
+		engineParamsMap = map[string][]resourcetypes.Resources{}
 		// map[nodename][]Resources
-		workloadResourcesMap = map[string][]types.Resources{}
+		workloadResourcesMap = map[string][]resourcetypes.Resources{}
 	)
 
 	_ = c.pool.Invoke(func() {
@@ -151,7 +152,7 @@ func (c *Calcium) doCreateWorkloads(ctx context.Context, opts *types.DeployOptio
 				}
 				for nodename, rollbackIndices := range rollbackMap {
 					if e := c.withNodePodLocked(ctx, nodename, func(ctx context.Context, node *types.Node) error {
-						rollbackResources := utils.Map(rollbackIndices, func(idx int) types.Resources {
+						rollbackResources := utils.Map(rollbackIndices, func(idx int) resourcetypes.Resources {
 							return workloadResourcesMap[nodename][idx]
 						})
 						return c.rmgr.RollbackAlloc(ctx, nodename, rollbackResources)
@@ -173,8 +174,8 @@ func (c *Calcium) doCreateWorkloads(ctx context.Context, opts *types.DeployOptio
 func (c *Calcium) doDeployWorkloads(ctx context.Context,
 	ch chan *types.CreateWorkloadMessage,
 	opts *types.DeployOptions,
-	engineParamsMap map[string][]types.Resources,
-	workloadResourcesMap map[string][]types.Resources,
+	engineParamsMap map[string][]resourcetypes.Resources,
+	workloadResourcesMap map[string][]resourcetypes.Resources,
 	deployMap map[string]int) (_ map[string][]int, err error) {
 
 	wg := sync.WaitGroup{}
@@ -220,8 +221,8 @@ func (c *Calcium) doDeployWorkloadsOnNode(ctx context.Context,
 	nodename string,
 	opts *types.DeployOptions,
 	deploy int,
-	engineParams []types.Resources,
-	workloadResources []types.Resources,
+	engineParams []resourcetypes.Resources,
+	workloadResources []resourcetypes.Resources,
 	seq int) (indices []int, err error) {
 
 	logger := log.WithFunc("calcium.doDeployWorkloadsOnNode").WithField("node", nodename).WithField("ident", opts.ProcessIdent).WithField("deploy", deploy).WithField("seq", seq)
@@ -292,15 +293,15 @@ func (c *Calcium) doDeployOneWorkload(
 	node *types.Node,
 	opts *types.DeployOptions,
 	msg *types.CreateWorkloadMessage,
-	config *enginetypes.VirtualizationCreateOptions,
+	createOpts *enginetypes.VirtualizationCreateOptions,
 	decrProcessing bool,
 ) (err error) {
 	logger := log.WithFunc("calcium.doDeployWorkload").WithField("node", node.Name).WithField("ident", opts.ProcessIdent).WithField("msg", msg)
 	workload := &types.Workload{
 		Resources:    msg.Resources,
 		EngineParams: msg.EngineParams,
-		Name:         config.Name,
-		Labels:       config.Labels,
+		Name:         createOpts.Name,
+		Labels:       createOpts.Labels,
 		Podname:      opts.Podname,
 		Nodename:     node.Name,
 		Hook:         opts.Entrypoint.Hook,
@@ -324,7 +325,7 @@ func (c *Calcium) doDeployOneWorkload(
 		ctx,
 		// create workload
 		func(ctx context.Context) error {
-			created, err := node.Engine.VirtualizationCreate(ctx, config)
+			created, err := node.Engine.VirtualizationCreate(ctx, createOpts)
 			if err != nil {
 				return err
 			}
@@ -437,48 +438,48 @@ func (c *Calcium) doDeployOneWorkload(
 }
 
 func (c *Calcium) doMakeWorkloadOptions(ctx context.Context, no int, msg *types.CreateWorkloadMessage, opts *types.DeployOptions, node *types.Node) *enginetypes.VirtualizationCreateOptions {
-	config := &enginetypes.VirtualizationCreateOptions{}
+	createOpts := &enginetypes.VirtualizationCreateOptions{}
 	// general
-	config.EngineParams = msg.EngineParams
-	config.RawArgs = opts.RawArgs
-	config.Lambda = opts.Lambda
-	config.User = opts.User
-	config.DNS = opts.DNS
-	config.Image = opts.Image
-	config.Stdin = opts.OpenStdin
-	config.Hosts = opts.ExtraHosts
-	config.Debug = opts.Debug
-	config.Networks = opts.Networks
+	createOpts.EngineParams = msg.EngineParams
+	createOpts.RawArgs = opts.RawArgs
+	createOpts.Lambda = opts.Lambda
+	createOpts.User = opts.User
+	createOpts.DNS = opts.DNS
+	createOpts.Image = opts.Image
+	createOpts.Stdin = opts.OpenStdin
+	createOpts.Hosts = opts.ExtraHosts
+	createOpts.Debug = opts.Debug
+	createOpts.Networks = opts.Networks
 
 	// entry
 	entry := opts.Entrypoint
-	config.WorkingDir = entry.Dir
-	config.Privileged = entry.Privileged
-	config.Sysctl = entry.Sysctls
-	config.Publish = entry.Publish
-	config.Restart = entry.Restart
+	createOpts.WorkingDir = entry.Dir
+	createOpts.Privileged = entry.Privileged
+	createOpts.Sysctl = entry.Sysctls
+	createOpts.Publish = entry.Publish
+	createOpts.Restart = entry.Restart
 	if entry.Log != nil {
-		config.LogType = entry.Log.Type
-		config.LogConfig = map[string]string{}
+		createOpts.LogType = entry.Log.Type
+		createOpts.LogConfig = map[string]string{}
 		for k, v := range entry.Log.Config {
-			config.LogConfig[k] = v
+			createOpts.LogConfig[k] = v
 		}
 	}
 	// name
 	suffix := utils.RandomString(6)
-	config.Name = utils.MakeWorkloadName(opts.Name, opts.Entrypoint.Name, suffix)
-	msg.WorkloadName = config.Name
+	createOpts.Name = utils.MakeWorkloadName(opts.Name, opts.Entrypoint.Name, suffix)
+	msg.WorkloadName = createOpts.Name
 	// command and user
 	// extra args is dynamically
-	config.Cmd = opts.Entrypoint.Commands
+	createOpts.Cmd = opts.Entrypoint.Commands
 	// env
 	env := append(opts.Env, fmt.Sprintf("APP_NAME=%s", opts.Name)) //nolint
 	env = append(env, fmt.Sprintf("ERU_POD=%s", opts.Podname))
 	env = append(env, fmt.Sprintf("ERU_NODE_NAME=%s", node.Name))
 	env = append(env, fmt.Sprintf("ERU_WORKLOAD_SEQ=%d", no))
-	config.Env = env
+	createOpts.Env = env
 	// basic labels, bind to LabelMeta
-	config.Labels = map[string]string{
+	createOpts.Labels = map[string]string{
 		cluster.ERUMark: "1",
 		cluster.LabelMeta: utils.EncodeMetaInLabel(ctx, &types.LabelMeta{
 			Publish:     opts.Entrypoint.Publish,
@@ -488,8 +489,8 @@ func (c *Calcium) doMakeWorkloadOptions(ctx context.Context, no int, msg *types.
 		cluster.LabelCoreID:   c.identifier,
 	}
 	for key, value := range opts.Labels {
-		config.Labels[key] = value
+		createOpts.Labels[key] = value
 	}
 
-	return config
+	return createOpts
 }
diff --git a/cluster/calcium/create_test.go b/cluster/calcium/create_test.go
index 000bb324e..af4efe60b 100644
--- a/cluster/calcium/create_test.go
+++ b/cluster/calcium/create_test.go
@@ -13,6 +13,7 @@ import (
 	lockmocks "github.com/projecteru2/core/lock/mocks"
 	resourcemocks "github.com/projecteru2/core/resource/mocks"
 	plugintypes "github.com/projecteru2/core/resource/plugins/types"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	storemocks "github.com/projecteru2/core/store/mocks"
 	"github.com/projecteru2/core/strategy"
 	"github.com/projecteru2/core/types"
@@ -68,7 +69,7 @@ func TestCreateWorkloadTxn(t *testing.T) {
 		Count:          2,
 		DeployStrategy: strategy.Auto,
 		Podname:        "p1",
-		Resources:      types.Resources{},
+		Resources:      resourcetypes.Resources{},
 		Image:          "zc:test",
 		Entrypoint: &types.Entrypoint{
 			Name: "good-entrypoint",
@@ -149,8 +150,8 @@ func TestCreateWorkloadTxn(t *testing.T) {
 	assert.True(t, walCommitted)
 	walCommitted = false
 	rmgr.On("Alloc", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(
-		[]types.Resources{{}, {}},
-		[]types.Resources{
+		[]resourcetypes.Resources{{}, {}},
+		[]resourcetypes.Resources{
 			{node1.Name: {}},
 			{node2.Name: {}},
 		},
diff --git a/cluster/calcium/dissociate.go b/cluster/calcium/dissociate.go
index 25b3bf526..538096d7d 100644
--- a/cluster/calcium/dissociate.go
+++ b/cluster/calcium/dissociate.go
@@ -5,6 +5,7 @@ import (
 
 	"github.com/projecteru2/core/log"
 	"github.com/projecteru2/core/resource/plugins"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	"github.com/projecteru2/core/types"
 	"github.com/projecteru2/core/utils"
 )
@@ -32,7 +33,7 @@ func (c *Calcium) DissociateWorkload(ctx context.Context, IDs []string) (chan *t
 							ctx,
 							// if
 							func(ctx context.Context) (err error) {
-								_, _, err = c.rmgr.SetNodeResourceUsage(ctx, node.Name, nil, nil, []types.Resources{workload.Resources}, true, plugins.Decr)
+								_, _, err = c.rmgr.SetNodeResourceUsage(ctx, node.Name, nil, nil, []resourcetypes.Resources{workload.Resources}, true, plugins.Decr)
 								return err
 							},
 							// then
@@ -44,7 +45,7 @@ func (c *Calcium) DissociateWorkload(ctx context.Context, IDs []string) (chan *t
 								if failedByCond {
 									return nil
 								}
-								_, _, err = c.rmgr.SetNodeResourceUsage(ctx, node.Name, nil, nil, []types.Resources{workload.Resources}, true, plugins.Incr)
+								_, _, err = c.rmgr.SetNodeResourceUsage(ctx, node.Name, nil, nil, []resourcetypes.Resources{workload.Resources}, true, plugins.Incr)
 								return err
 							},
 							c.config.GlobalTimeout,
diff --git a/cluster/calcium/dissociate_test.go b/cluster/calcium/dissociate_test.go
index b843d47f8..8e07998f7 100644
--- a/cluster/calcium/dissociate_test.go
+++ b/cluster/calcium/dissociate_test.go
@@ -7,6 +7,7 @@ import (
 
 	lockmocks "github.com/projecteru2/core/lock/mocks"
 	resourcemocks "github.com/projecteru2/core/resource/mocks"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	storemocks "github.com/projecteru2/core/store/mocks"
 	"github.com/projecteru2/core/types"
 
@@ -25,7 +26,7 @@ func TestDissociateWorkload(t *testing.T) {
 	lock.On("Unlock", mock.Anything).Return(nil)
 
 	c1 := &types.Workload{
-		Resources: types.Resources{},
+		Resources: resourcetypes.Resources{},
 		ID:        "c1",
 		Podname:   "p1",
 		Nodename:  "node1",
@@ -55,8 +56,8 @@ func TestDissociateWorkload(t *testing.T) {
 	store.On("CreateLock", mock.Anything, mock.Anything).Return(lock, nil)
 	// failed by RemoveWorkload
 	rmgr.On("SetNodeResourceUsage", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(
-		types.Resources{},
-		types.Resources{},
+		resourcetypes.Resources{},
+		resourcetypes.Resources{},
 		nil,
 	)
 	store.On("RemoveWorkload", mock.Anything, mock.Anything).Return(types.ErrMockError).Once()
diff --git a/cluster/calcium/lambda_test.go b/cluster/calcium/lambda_test.go
index 5fbf8505c..beaa8adb4 100644
--- a/cluster/calcium/lambda_test.go
+++ b/cluster/calcium/lambda_test.go
@@ -12,6 +12,7 @@ import (
 	lockmocks "github.com/projecteru2/core/lock/mocks"
 	resourcemocks "github.com/projecteru2/core/resource/mocks"
 	plugintypes "github.com/projecteru2/core/resource/plugins/types"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	storemocks "github.com/projecteru2/core/store/mocks"
 	"github.com/projecteru2/core/strategy"
 	"github.com/projecteru2/core/types"
@@ -41,7 +42,7 @@ func TestRunAndWaitFailedThenWALCommitted(t *testing.T) {
 		Count:          2,
 		DeployStrategy: strategy.Auto,
 		Podname:        "p1",
-		Resources:      types.Resources{},
+		Resources:      resourcetypes.Resources{},
 		Image:          "zc:test",
 		Entrypoint: &types.Entrypoint{
 			Name: "good-entrypoint",
@@ -77,7 +78,7 @@ func TestLambdaWithWorkloadIDReturned(t *testing.T) {
 		Count:          2,
 		DeployStrategy: strategy.Auto,
 		Podname:        "p1",
-		Resources:      types.Resources{},
+		Resources:      resourcetypes.Resources{},
 		Image:          "zc:test",
 		Entrypoint: &types.Entrypoint{
 			Name: "good-entrypoint",
@@ -129,7 +130,7 @@ func TestLambdaWithError(t *testing.T) {
 		Count:          2,
 		DeployStrategy: strategy.Auto,
 		Podname:        "p1",
-		Resources:      types.Resources{},
+		Resources:      resourcetypes.Resources{},
 		Image:          "zc:test",
 		Entrypoint: &types.Entrypoint{
 			Name: "good-entrypoint",
@@ -195,8 +196,8 @@ func newLambdaCluster(t *testing.T) (*Calcium, []*types.Node) {
 	store := c.store.(*storemocks.Store)
 	rmgr := c.rmgr.(*resourcemocks.Manager)
 	rmgr.On("GetNodeResourceInfo", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(
-		types.Resources{},
-		types.Resources{},
+		resourcetypes.Resources{},
+		resourcetypes.Resources{},
 		[]string{},
 		nil,
 	)
@@ -218,8 +219,8 @@ func newLambdaCluster(t *testing.T) (*Calcium, []*types.Node) {
 		20, nil,
 	)
 	rmgr.On("Alloc", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(
-		[]types.Resources{{}, {}},
-		[]types.Resources{
+		[]resourcetypes.Resources{{}, {}},
+		[]resourcetypes.Resources{
 			{node1.Name: {}},
 			{node2.Name: {}},
 		},
diff --git a/cluster/calcium/node.go b/cluster/calcium/node.go
index 7d2db0228..ee3b6f114 100644
--- a/cluster/calcium/node.go
+++ b/cluster/calcium/node.go
@@ -8,6 +8,7 @@ import (
 	enginetypes "github.com/projecteru2/core/engine/types"
 	"github.com/projecteru2/core/log"
 	"github.com/projecteru2/core/resource/plugins"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	"github.com/projecteru2/core/types"
 	"github.com/projecteru2/core/utils"
 )
@@ -20,7 +21,7 @@ func (c *Calcium) AddNode(ctx context.Context, opts *types.AddNodeOptions) (*typ
 		logger.Error(ctx, err)
 		return nil, err
 	}
-	var res types.Resources
+	var res resourcetypes.Resources
 	var node *types.Node
 	var err error
 
@@ -212,7 +213,7 @@ func (c *Calcium) SetNode(ctx context.Context, opts *types.SetNodeOptions) (*typ
 			n.Labels = opts.Labels
 		}
 
-		var origin types.Resources
+		var origin resourcetypes.Resources
 		return utils.Txn(ctx,
 			// if: update node resource capacity success
 			func(ctx context.Context) error {
diff --git a/cluster/calcium/node_test.go b/cluster/calcium/node_test.go
index d26cdf166..839db530c 100644
--- a/cluster/calcium/node_test.go
+++ b/cluster/calcium/node_test.go
@@ -12,6 +12,7 @@ import (
 	lockmocks "github.com/projecteru2/core/lock/mocks"
 	resourcemocks "github.com/projecteru2/core/resource/mocks"
 	plugintypes "github.com/projecteru2/core/resource/plugins/types"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	storemocks "github.com/projecteru2/core/store/mocks"
 	"github.com/projecteru2/core/types"
 
@@ -42,7 +43,7 @@ func TestAddNode(t *testing.T) {
 	assert.Error(t, err)
 	rmgr.AssertExpectations(t)
 	rmgr.On("AddNode", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(
-		types.Resources{}, nil)
+		resourcetypes.Resources{}, nil)
 	rmgr.On("RemoveNode", mock.Anything, mock.Anything).Return(nil)
 
 	// failed by store.AddNode
@@ -248,7 +249,7 @@ func TestSetNode(t *testing.T) {
 	opts.Labels = labels
 
 	// failed by SetNodeResourceCapacity
-	opts.Resources = types.Resources{"a": {"a": 1}}
+	opts.Resources = resourcetypes.Resources{"a": {"a": 1}}
 	rmgr.On("SetNodeResourceCapacity", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(
 		nil, nil, types.ErrMockError,
 	).Once()
diff --git a/cluster/calcium/realloc.go b/cluster/calcium/realloc.go
index 1289fe6b4..b620a18d1 100644
--- a/cluster/calcium/realloc.go
+++ b/cluster/calcium/realloc.go
@@ -7,6 +7,7 @@ import (
 
 	enginetypes "github.com/projecteru2/core/engine/types"
 	"github.com/projecteru2/core/log"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	"github.com/projecteru2/core/types"
 	"github.com/projecteru2/core/utils"
 )
@@ -31,9 +32,9 @@ func (c *Calcium) ReallocResource(ctx context.Context, opts *types.ReallocOption
 }
 
 func (c *Calcium) doReallocOnNode(ctx context.Context, node *types.Node, workload *types.Workload, originWorkload types.Workload, opts *types.ReallocOptions) error {
-	var resources types.Resources
-	var deltaResources types.Resources
-	var engineParams types.Resources
+	var resources resourcetypes.Resources
+	var deltaResources resourcetypes.Resources
+	var engineParams resourcetypes.Resources
 	var err error
 
 	logger := log.WithFunc("calcium.doReallocOnNode").WithField("opts", opts)
diff --git a/cluster/calcium/realloc_test.go b/cluster/calcium/realloc_test.go
index 380657b76..c03b45ac8 100644
--- a/cluster/calcium/realloc_test.go
+++ b/cluster/calcium/realloc_test.go
@@ -10,6 +10,7 @@ import (
 	lockmocks "github.com/projecteru2/core/lock/mocks"
 	resourcemocks "github.com/projecteru2/core/resource/mocks"
 	plugintypes "github.com/projecteru2/core/resource/plugins/types"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	storemocks "github.com/projecteru2/core/store/mocks"
 	"github.com/projecteru2/core/types"
 
@@ -47,7 +48,7 @@ func TestRealloc(t *testing.T) {
 				ID:        "c1",
 				Podname:   "p1",
 				Engine:    engine,
-				Resources: types.Resources{},
+				Resources: resourcetypes.Resources{},
 				Nodename:  "node1",
 			},
 		}
@@ -56,7 +57,7 @@ func TestRealloc(t *testing.T) {
 	store.On("GetWorkload", mock.Anything, "c1").Return(newC1(context.Background(), nil)[0], nil)
 	opts := &types.ReallocOptions{
 		ID:        "c1",
-		Resources: types.Resources{},
+		Resources: resourcetypes.Resources{},
 	}
 
 	// failed by GetNode
@@ -76,14 +77,14 @@ func TestRealloc(t *testing.T) {
 
 	// failed by plugin
 	rmgr.On("Realloc", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(
-		types.Resources{}, nil, nil, types.ErrMockError,
+		resourcetypes.Resources{}, nil, nil, types.ErrMockError,
 	).Once()
 	err = c.ReallocResource(ctx, opts)
 	assert.Error(t, err)
 	rmgr.On("Realloc", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(
-		types.Resources{},
-		types.Resources{},
-		types.Resources{},
+		resourcetypes.Resources{},
+		resourcetypes.Resources{},
+		resourcetypes.Resources{},
 		nil,
 	)
 	rmgr.On("RollbackRealloc", mock.Anything, mock.Anything, mock.Anything).Return(nil)
diff --git a/cluster/calcium/remap_test.go b/cluster/calcium/remap_test.go
index 13d297e5d..ad25a1d52 100644
--- a/cluster/calcium/remap_test.go
+++ b/cluster/calcium/remap_test.go
@@ -9,6 +9,7 @@ import (
 	lockmocks "github.com/projecteru2/core/lock/mocks"
 	"github.com/projecteru2/core/log"
 	resourcemocks "github.com/projecteru2/core/resource/mocks"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	storemocks "github.com/projecteru2/core/store/mocks"
 	"github.com/projecteru2/core/types"
 	"github.com/stretchr/testify/assert"
@@ -20,19 +21,19 @@ func TestRemapResource(t *testing.T) {
 	store := c.store.(*storemocks.Store)
 	rmgr := c.rmgr.(*resourcemocks.Manager)
 	rmgr.On("GetNodeResourceInfo", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(
-		types.Resources{"test": {"abc": 123}},
-		types.Resources{"test": {"abc": 123}},
+		resourcetypes.Resources{"test": {"abc": 123}},
+		resourcetypes.Resources{"test": {"abc": 123}},
 		[]string{types.ErrMockError.Error()},
 		nil)
 	rmgr.On("Remap", mock.Anything, mock.Anything, mock.Anything).Return(
-		types.Resources{},
+		resourcetypes.Resources{},
 		nil,
 	)
 	engine := &enginemocks.API{}
 	node := &types.Node{Engine: engine}
 
 	workload := &types.Workload{
-		Resources: types.Resources{},
+		Resources: resourcetypes.Resources{},
 	}
 	store.On("ListNodeWorkloads", mock.Anything, mock.Anything, mock.Anything).Return([]*types.Workload{workload}, nil)
 	ch := make(chan enginetypes.VirtualizationRemapMessage, 1)
diff --git a/cluster/calcium/remove.go b/cluster/calcium/remove.go
index 8b78f14e2..31d9fa279 100644
--- a/cluster/calcium/remove.go
+++ b/cluster/calcium/remove.go
@@ -7,6 +7,7 @@ import (
 
 	"github.com/projecteru2/core/log"
 	"github.com/projecteru2/core/resource/plugins"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	"github.com/projecteru2/core/types"
 	"github.com/projecteru2/core/utils"
 )
@@ -40,7 +41,7 @@ func (c *Calcium) RemoveWorkload(ctx context.Context, IDs []string, force bool)
 									ctx,
 									// if
 									func(ctx context.Context) error {
-										_, _, err = c.rmgr.SetNodeResourceUsage(ctx, node.Name, nil, nil, []types.Resources{workload.Resources}, true, plugins.Decr)
+										_, _, err = c.rmgr.SetNodeResourceUsage(ctx, node.Name, nil, nil, []resourcetypes.Resources{workload.Resources}, true, plugins.Decr)
 										return err
 									},
 									// then
@@ -55,7 +56,7 @@ func (c *Calcium) RemoveWorkload(ctx context.Context, IDs []string, force bool)
 										if failedByCond {
 											return nil
 										}
-										_, _, err = c.rmgr.SetNodeResourceUsage(ctx, node.Name, nil, nil, []types.Resources{workload.Resources}, true, plugins.Incr)
+										_, _, err = c.rmgr.SetNodeResourceUsage(ctx, node.Name, nil, nil, []resourcetypes.Resources{workload.Resources}, true, plugins.Incr)
 										return err
 									},
 									c.config.GlobalTimeout,
diff --git a/cluster/calcium/remove_test.go b/cluster/calcium/remove_test.go
index c56047d79..cd8343faf 100644
--- a/cluster/calcium/remove_test.go
+++ b/cluster/calcium/remove_test.go
@@ -13,6 +13,7 @@ import (
 	"github.com/projecteru2/core/types"
 
 	"github.com/cockroachdb/errors"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 )
@@ -27,8 +28,8 @@ func TestRemoveWorkload(t *testing.T) {
 	rmgr := c.rmgr.(*resourcemocks.Manager)
 	rmgr.On("GetNodeResourceInfo", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, nil, nil, nil)
 	rmgr.On("SetNodeResourceUsage", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(
-		types.Resources{},
-		types.Resources{},
+		resourcetypes.Resources{},
+		resourcetypes.Resources{},
 		nil,
 	)
 	rmgr.On("GetNodeMetrics", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return([]*plugintypes.Metrics{}, nil)
diff --git a/cluster/calcium/resource_test.go b/cluster/calcium/resource_test.go
index 68a586708..ac534274a 100644
--- a/cluster/calcium/resource_test.go
+++ b/cluster/calcium/resource_test.go
@@ -7,6 +7,7 @@ import (
 	enginemocks "github.com/projecteru2/core/engine/mocks"
 	lockmocks "github.com/projecteru2/core/lock/mocks"
 	resourcemocks "github.com/projecteru2/core/resource/mocks"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	storemocks "github.com/projecteru2/core/store/mocks"
 	"github.com/projecteru2/core/types"
 
@@ -48,8 +49,8 @@ func TestPodResource(t *testing.T) {
 	assert.NotEmpty(t, msg.Diffs)
 	store.AssertExpectations(t)
 	workloads := []*types.Workload{
-		{Resources: types.Resources{}},
-		{Resources: types.Resources{}},
+		{Resources: resourcetypes.Resources{}},
+		{Resources: resourcetypes.Resources{}},
 	}
 	store.On("ListNodeWorkloads", mock.Anything, mock.Anything, mock.Anything).Return(workloads, nil)
 
@@ -63,8 +64,8 @@ func TestPodResource(t *testing.T) {
 	assert.NotEmpty(t, msg.Diffs)
 	store.AssertExpectations(t)
 	rmgr.On("GetNodeResourceInfo", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(
-		types.Resources{"test": {"abc": 123}},
-		types.Resources{"test": {"abc": 123}},
+		resourcetypes.Resources{"test": {"abc": 123}},
+		resourcetypes.Resources{"test": {"abc": 123}},
 		[]string{},
 		nil)
 
@@ -98,14 +99,14 @@ func TestNodeResource(t *testing.T) {
 	store.On("CreateLock", mock.Anything, mock.Anything).Return(lock, nil)
 
 	rmgr.On("GetNodeResourceInfo", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(
-		types.Resources{"test": {"abc": 123}},
-		types.Resources{"test": {"abc": 123}},
+		resourcetypes.Resources{"test": {"abc": 123}},
+		resourcetypes.Resources{"test": {"abc": 123}},
 		[]string{},
 		nil)
 
 	workloads := []*types.Workload{
-		{Resources: types.Resources{}, Engine: engine},
-		{Resources: types.Resources{}, Engine: engine},
+		{Resources: resourcetypes.Resources{}, Engine: engine},
+		{Resources: resourcetypes.Resources{}, Engine: engine},
 	}
 	store.On("ListNodeWorkloads", mock.Anything, mock.Anything, mock.Anything).Return(workloads, nil)
 	engine.On("VirtualizationInspect", mock.Anything, mock.Anything).Return(nil, types.ErrMockError)
diff --git a/cluster/calcium/wal_test.go b/cluster/calcium/wal_test.go
index 579bc2586..6c8cdbca1 100644
--- a/cluster/calcium/wal_test.go
+++ b/cluster/calcium/wal_test.go
@@ -12,6 +12,7 @@ import (
 	lockmocks "github.com/projecteru2/core/lock/mocks"
 	resourcemocks "github.com/projecteru2/core/resource/mocks"
 	plugintypes "github.com/projecteru2/core/resource/plugins/types"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	storemocks "github.com/projecteru2/core/store/mocks"
 	"github.com/projecteru2/core/types"
 
@@ -26,8 +27,8 @@ func TestHandleCreateWorkloadNoHandle(t *testing.T) {
 	c.wal = wal
 	rmgr := c.rmgr.(*resourcemocks.Manager)
 	rmgr.On("GetNodeResourceInfo", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(
-		types.Resources{},
-		types.Resources{},
+		resourcetypes.Resources{},
+		resourcetypes.Resources{},
 		[]string{},
 		nil,
 	)
@@ -58,8 +59,8 @@ func TestHandleCreateWorkloadError(t *testing.T) {
 	c.wal = wal
 	rmgr := c.rmgr.(*resourcemocks.Manager)
 	rmgr.On("GetNodeResourceInfo", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(
-		types.Resources{},
-		types.Resources{},
+		resourcetypes.Resources{},
+		resourcetypes.Resources{},
 		[]string{},
 		nil,
 	)
@@ -112,8 +113,8 @@ func TestHandleCreateWorkloadHandled(t *testing.T) {
 	c.wal = wal
 	rmgr := c.rmgr.(*resourcemocks.Manager)
 	rmgr.On("GetNodeResourceInfo", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(
-		types.Resources{},
-		types.Resources{},
+		resourcetypes.Resources{},
+		resourcetypes.Resources{},
 		[]string{},
 		nil,
 	)
@@ -160,19 +161,19 @@ func TestHandleCreateLambda(t *testing.T) {
 	c.wal = wal
 	rmgr := c.rmgr.(*resourcemocks.Manager)
 	rmgr.On("GetNodeResourceInfo", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(
-		types.Resources{},
-		types.Resources{},
+		resourcetypes.Resources{},
+		resourcetypes.Resources{},
 		[]string{},
 		nil,
 	)
 	rmgr.On("SetNodeResourceUsage", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(
-		types.Resources{},
-		types.Resources{},
+		resourcetypes.Resources{},
+		resourcetypes.Resources{},
 		nil,
 	)
 	rmgr.On("GetNodeMetrics", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return([]*plugintypes.Metrics{}, nil)
 	rmgr.On("Remap", mock.Anything, mock.Anything, mock.Anything).Return(
-		types.Resources{},
+		resourcetypes.Resources{},
 		nil,
 	)
 
diff --git a/engine/mocks/fakeengine/mock.go b/engine/mocks/fakeengine/mock.go
index 9dcdee28c..3ad2d1366 100644
--- a/engine/mocks/fakeengine/mock.go
+++ b/engine/mocks/fakeengine/mock.go
@@ -7,6 +7,7 @@ import (
 	"io"
 
 	"github.com/docker/go-units"
+	"github.com/sanity-io/litter"
 	mock "github.com/stretchr/testify/mock"
 
 	"github.com/projecteru2/core/engine"
@@ -85,7 +86,9 @@ func MakeClient(ctx context.Context, config coretypes.Config, nodename, endpoint
 	e.On("BuildContent", mock.Anything, mock.Anything, mock.Anything).Return("BuildContent", buildContent, nil)
 	// virtualization
 	var ID string
-	e.On("VirtualizationCreate", mock.Anything, mock.Anything).Return(func(context.Context, *enginetypes.VirtualizationCreateOptions) *enginetypes.VirtualizationCreated {
+	e.On("VirtualizationCreate", mock.Anything, mock.Anything).Return(func(_ context.Context, opts *enginetypes.VirtualizationCreateOptions) *enginetypes.VirtualizationCreated {
+		tmp, _ := engine.MakeVirtualizationResource(opts.EngineParams)
+		litter.Dump(tmp)
 		ID = utils.RandomString(64)
 		return &enginetypes.VirtualizationCreated{ID: ID, Name: "mock-test-cvm" + utils.RandomString(6)}
 	}, nil)
@@ -108,6 +111,5 @@ func MakeClient(ctx context.Context, config coretypes.Config, nodename, endpoint
 	e.On("VirtualizationWait", mock.Anything, mock.Anything, mock.Anything).Return(&enginetypes.VirtualizationWaitResult{Message: "", Code: 0}, nil)
 	e.On("VirtualizationUpdateResource", mock.Anything, mock.Anything, mock.Anything).Return(nil)
 	e.On("VirtualizationCopyFrom", mock.Anything, mock.Anything, mock.Anything).Return([]byte("d1...\nd2...\n"), 0, 0, int64(0), nil)
-	//	e.On("ResourceValidate", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
 	return e, nil
 }
diff --git a/engine/transform.go b/engine/transform.go
index ba8324034..44a46a9c1 100644
--- a/engine/transform.go
+++ b/engine/transform.go
@@ -8,8 +8,19 @@ import (
 // MakeVirtualizationResource .
 // TODO Werid, should revise
 func MakeVirtualizationResource(engineParams interface{}) (types.VirtualizationResource, error) {
+	// trans to Resources first because cycle import not allow here
+	t := map[string]map[string]interface{}{}
 	var res types.VirtualizationResource
-	if err := mapstructure.Decode(engineParams, &res); err != nil {
+	if err := mapstructure.Decode(engineParams, &t); err != nil {
+		return res, err
+	}
+	r := map[string]interface{}{}
+	for _, p := range t {
+		for k, v := range p {
+			r[k] = v
+		}
+	}
+	if err := mapstructure.Decode(r, &res); err != nil {
 		return res, err
 	}
 	res.EngineParams = engineParams
diff --git a/engine/types/virtualization.go b/engine/types/virtualization.go
index 3450303cf..29f7ec7ec 100644
--- a/engine/types/virtualization.go
+++ b/engine/types/virtualization.go
@@ -1,6 +1,6 @@
 package types
 
-// VirtualizationResource define resources
+// VirtualizationResource1 define resources
 type VirtualizationResource struct {
 	EngineParams  interface{}                 `json:"-" mapstructure:"-"`
 	CPU           map[string]int64            `json:"cpu_map" mapstructure:"cpu_map"` // for cpu binding
diff --git a/resource/cobalt/alloc.go b/resource/cobalt/alloc.go
index 25a5f5616..a2873d605 100644
--- a/resource/cobalt/alloc.go
+++ b/resource/cobalt/alloc.go
@@ -6,7 +6,7 @@ import (
 	"github.com/projecteru2/core/log"
 	"github.com/projecteru2/core/resource/plugins"
 	plugintypes "github.com/projecteru2/core/resource/plugins/types"
-	"github.com/projecteru2/core/types"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	"github.com/projecteru2/core/utils"
 )
 
@@ -23,17 +23,17 @@ opts struct
 		},
 	}
 */
-func (m Manager) Alloc(ctx context.Context, nodename string, deployCount int, opts types.Resources) ([]types.Resources, []types.Resources, error) {
+func (m Manager) Alloc(ctx context.Context, nodename string, deployCount int, opts resourcetypes.Resources) ([]resourcetypes.Resources, []resourcetypes.Resources, error) {
 	logger := log.WithFunc("resource.coblat.Alloc")
 
 	// index -> no, map by plugin name
-	workloadsParams := make([]types.Resources, deployCount)
-	engineParams := make([]types.Resources, deployCount)
+	workloadsParams := make([]resourcetypes.Resources, deployCount)
+	engineParams := make([]resourcetypes.Resources, deployCount)
 
 	// init engine args
 	for i := 0; i < deployCount; i++ {
-		workloadsParams[i] = types.Resources{}
-		engineParams[i] = types.Resources{}
+		workloadsParams[i] = resourcetypes.Resources{}
+		engineParams[i] = resourcetypes.Resources{}
 	}
 
 	return workloadsParams, engineParams, utils.PCR(ctx,
@@ -86,7 +86,7 @@ func (m Manager) Alloc(ctx context.Context, nodename string, deployCount int, op
 }
 
 // RollbackAlloc rollbacks the allocated resource
-func (m Manager) RollbackAlloc(ctx context.Context, nodename string, workloadsParams []types.Resources) error {
+func (m Manager) RollbackAlloc(ctx context.Context, nodename string, workloadsParams []resourcetypes.Resources) error {
 	_, _, err := m.SetNodeResourceUsage(ctx, nodename, nil, nil, workloadsParams, true, plugins.Decr)
 	return err
 }
diff --git a/resource/cobalt/node.go b/resource/cobalt/node.go
index fd6eb1b5f..4b7150ace 100644
--- a/resource/cobalt/node.go
+++ b/resource/cobalt/node.go
@@ -7,6 +7,7 @@ import (
 	"github.com/cockroachdb/errors"
 	enginetypes "github.com/projecteru2/core/engine/types"
 	plugintypes "github.com/projecteru2/core/resource/plugins/types"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	"github.com/sanity-io/litter"
 	"golang.org/x/exp/slices"
 
@@ -17,9 +18,9 @@ import (
 )
 
 // AddNode .
-func (m Manager) AddNode(ctx context.Context, nodename string, opts types.Resources, nodeInfo *enginetypes.Info) (types.Resources, error) {
+func (m Manager) AddNode(ctx context.Context, nodename string, opts resourcetypes.Resources, nodeInfo *enginetypes.Info) (resourcetypes.Resources, error) {
 	logger := log.WithFunc("resource.cobalt.AddNode").WithField("node", nodename)
-	res := types.Resources{}
+	res := resourcetypes.Resources{}
 	rollbackPlugins := []plugins.Plugin{}
 
 	return res, utils.PCR(ctx,
@@ -73,8 +74,8 @@ func (m Manager) AddNode(ctx context.Context, nodename string, opts types.Resour
 // RemoveNode .
 func (m Manager) RemoveNode(ctx context.Context, nodename string) error {
 	logger := log.WithFunc("resource.cobalt.RemoveNode").WithField("node", nodename)
-	var nodeCapacity types.Resources
-	var nodeUsage types.Resources
+	var nodeCapacity resourcetypes.Resources
+	var nodeUsage resourcetypes.Resources
 	rollbackPlugins := []plugins.Plugin{}
 
 	return utils.PCR(ctx,
@@ -163,9 +164,9 @@ func (m Manager) GetMostIdleNode(ctx context.Context, nodenames []string) (strin
 }
 
 // GetNodeResourceInfo .
-func (m Manager) GetNodeResourceInfo(ctx context.Context, nodename string, workloads []*types.Workload, fix bool) (types.Resources, types.Resources, []string, error) {
-	nodeCapacity := types.Resources{}
-	nodeUsage := types.Resources{}
+func (m Manager) GetNodeResourceInfo(ctx context.Context, nodename string, workloads []*types.Workload, fix bool) (resourcetypes.Resources, resourcetypes.Resources, []string, error) {
+	nodeCapacity := resourcetypes.Resources{}
+	nodeUsage := resourcetypes.Resources{}
 	resourceDiffs := []string{}
 
 	ps := m.plugins
@@ -211,27 +212,27 @@ func (m Manager) GetNodeResourceInfo(ctx context.Context, nodename string, workl
 }
 
 // SetNodeResourceUsage .
-func (m Manager) SetNodeResourceUsage(ctx context.Context, nodename string, nodeResource types.Resources, nodeResourceRequest types.Resources, workloadsResource []types.Resources, delta bool, incr bool) (types.Resources, types.Resources, error) {
+func (m Manager) SetNodeResourceUsage(ctx context.Context, nodename string, nodeResource resourcetypes.Resources, nodeResourceRequest resourcetypes.Resources, workloadsResource []resourcetypes.Resources, delta bool, incr bool) (resourcetypes.Resources, resourcetypes.Resources, error) {
 	logger := log.WithFunc("resource.cobalt.SetNodeResourceUsage")
-	wrksResource := map[string][]types.RawParams{}
+	wrksResource := map[string][]resourcetypes.RawParams{}
 	rollbackPlugins := []plugins.Plugin{}
-	before := types.Resources{}
-	after := types.Resources{}
+	before := resourcetypes.Resources{}
+	after := resourcetypes.Resources{}
 
 	return before, after, utils.PCR(ctx,
 		func(ctx context.Context) error {
-			// prepare: covert []types.Resources to map[plugin]types.Resources
+			// prepare: covert []resourcetypes.Resources to map[plugin]resourcetypes.Resources
 			// [{"cpu-plugin": {"cpu": 1}}, {"cpu-plugin": {"cpu": 1}}] -> {"cpu-plugin": [{"cpu": 1}, {"cpu": 1}]}
 			for _, workloadResource := range workloadsResource {
 				for plugin, params := range workloadResource {
 					if _, ok := wrksResource[plugin]; !ok {
-						wrksResource[plugin] = []types.RawParams{}
+						wrksResource[plugin] = []resourcetypes.RawParams{}
 					}
 					wrksResource[plugin] = append(wrksResource[plugin], params)
 				}
 			}
 			if nodeResourceRequest == nil {
-				nodeResourceRequest = types.Resources{}
+				nodeResourceRequest = resourcetypes.Resources{}
 			}
 			return nil
 		},
@@ -273,7 +274,7 @@ func (m Manager) SetNodeResourceUsage(ctx context.Context, nodename string, node
 // GetNodesDeployCapacity returns available nodes which meet all the requirements
 // the caller should require locks
 // pure calculation
-func (m Manager) GetNodesDeployCapacity(ctx context.Context, nodenames []string, opts types.Resources) (map[string]*plugintypes.NodeDeployCapacity, int, error) {
+func (m Manager) GetNodesDeployCapacity(ctx context.Context, nodenames []string, opts resourcetypes.Resources) (map[string]*plugintypes.NodeDeployCapacity, int, error) {
 	logger := log.WithFunc("resource.cobalt.GetNodesDeployCapacity")
 	var resp map[string]*plugintypes.NodeDeployCapacity
 
@@ -310,17 +311,17 @@ func (m Manager) GetNodesDeployCapacity(ctx context.Context, nodenames []string,
 
 // SetNodeResourceCapacity updates node resource capacity
 // receives resource options instead of resource args
-func (m Manager) SetNodeResourceCapacity(ctx context.Context, nodename string, nodeResource types.Resources, nodeResourceRequest types.Resources, delta bool, incr bool) (types.Resources, types.Resources, error) {
+func (m Manager) SetNodeResourceCapacity(ctx context.Context, nodename string, nodeResource resourcetypes.Resources, nodeResourceRequest resourcetypes.Resources, delta bool, incr bool) (resourcetypes.Resources, resourcetypes.Resources, error) {
 	logger := log.WithFunc("resource.cobalt.SetNodeResourceCapacity").WithField("node", nodename)
 
 	rollbackPlugins := []plugins.Plugin{}
-	before := types.Resources{}
-	after := types.Resources{}
+	before := resourcetypes.Resources{}
+	after := resourcetypes.Resources{}
 
 	return before, after, utils.PCR(ctx,
 		func(ctx context.Context) error {
 			if nodeResourceRequest == nil {
-				nodeResourceRequest = types.Resources{}
+				nodeResourceRequest = resourcetypes.Resources{}
 			}
 			return nil
 		},
diff --git a/resource/cobalt/realloc.go b/resource/cobalt/realloc.go
index 9d558495d..a475010e3 100644
--- a/resource/cobalt/realloc.go
+++ b/resource/cobalt/realloc.go
@@ -6,16 +6,16 @@ import (
 	"github.com/projecteru2/core/log"
 	"github.com/projecteru2/core/resource/plugins"
 	plugintypes "github.com/projecteru2/core/resource/plugins/types"
-	"github.com/projecteru2/core/types"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	"github.com/projecteru2/core/utils"
 )
 
 // Realloc .
-func (m Manager) Realloc(ctx context.Context, nodename string, nodeResource types.Resources, opts types.Resources) (types.Resources, types.Resources, types.Resources, error) {
+func (m Manager) Realloc(ctx context.Context, nodename string, nodeResource resourcetypes.Resources, opts resourcetypes.Resources) (resourcetypes.Resources, resourcetypes.Resources, resourcetypes.Resources, error) {
 	logger := log.WithFunc("resource.cobalt.Realloc").WithField("node", nodename)
-	engineParams := types.Resources{}
-	deltaResources := types.Resources{}
-	workloadResource := types.Resources{}
+	engineParams := resourcetypes.Resources{}
+	deltaResources := resourcetypes.Resources{}
+	workloadResource := resourcetypes.Resources{}
 
 	return engineParams, deltaResources, workloadResource, utils.PCR(ctx,
 		// prepare: calculate engine args, delta node resource args and final workload resource args
@@ -46,7 +46,7 @@ func (m Manager) Realloc(ctx context.Context, nodename string, nodeResource type
 		// commit: update node resource
 		func(ctx context.Context) error {
 			// TODO 存在问题？？3个参数是完整的变化，差值变化，按照 workloads 的变化
-			if _, _, err := m.SetNodeResourceUsage(ctx, nodename, nil, nil, []types.Resources{workloadResource}, true, plugins.Incr); err != nil {
+			if _, _, err := m.SetNodeResourceUsage(ctx, nodename, nil, nil, []resourcetypes.Resources{workloadResource}, true, plugins.Incr); err != nil {
 				logger.Error(ctx, err, "failed to update nodename resource")
 				return err
 			}
@@ -61,7 +61,7 @@ func (m Manager) Realloc(ctx context.Context, nodename string, nodeResource type
 }
 
 // RollbackRealloc .
-func (m Manager) RollbackRealloc(ctx context.Context, nodename string, workloadParams types.Resources) error {
-	_, _, err := m.SetNodeResourceUsage(ctx, nodename, nil, nil, []types.Resources{workloadParams}, true, plugins.Decr)
+func (m Manager) RollbackRealloc(ctx context.Context, nodename string, workloadParams resourcetypes.Resources) error {
+	_, _, err := m.SetNodeResourceUsage(ctx, nodename, nil, nil, []resourcetypes.Resources{workloadParams}, true, plugins.Decr)
 	return err
 }
diff --git a/resource/cobalt/remap.go b/resource/cobalt/remap.go
index c6eecff37..ddf12fd74 100644
--- a/resource/cobalt/remap.go
+++ b/resource/cobalt/remap.go
@@ -6,12 +6,13 @@ import (
 	"github.com/projecteru2/core/log"
 	"github.com/projecteru2/core/resource/plugins"
 	plugintypes "github.com/projecteru2/core/resource/plugins/types"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	"github.com/projecteru2/core/types"
 )
 
 // Remap remaps resource and returns engine args for workloads. format: {"workload-1": {"cpus": ["1-3"]}}
 // remap doesn't change resource args
-func (m Manager) Remap(ctx context.Context, nodename string, workloads []*types.Workload) (types.Resources, error) {
+func (m Manager) Remap(ctx context.Context, nodename string, workloads []*types.Workload) (resourcetypes.Resources, error) {
 	logger := log.WithFunc("resource.cobalt.GetRemapArgs").WithField("node", nodename)
 	// call plugins to remap
 	resps, err := call(ctx, m.plugins, func(plugin plugins.Plugin) (*plugintypes.CalculateRemapResponse, error) {
@@ -29,12 +30,12 @@ func (m Manager) Remap(ctx context.Context, nodename string, workloads []*types.
 		return nil, err
 	}
 
-	enginesParams := types.Resources{}
+	enginesParams := resourcetypes.Resources{}
 	// merge engine args
 	for _, resp := range resps {
 		for workloadID, engineParams := range resp.EngineParamsMap {
 			if _, ok := enginesParams[workloadID]; !ok {
-				enginesParams[workloadID] = types.RawParams{}
+				enginesParams[workloadID] = resourcetypes.RawParams{}
 			}
 			v := enginesParams[workloadID]
 			vMerged, err := m.mergeEngineParams(ctx, v, engineParams)
diff --git a/resource/manager.go b/resource/manager.go
index afba868d4..df880f8fb 100644
--- a/resource/manager.go
+++ b/resource/manager.go
@@ -5,25 +5,26 @@ import (
 
 	enginetypes "github.com/projecteru2/core/engine/types"
 	plugintypes "github.com/projecteru2/core/resource/plugins/types"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	"github.com/projecteru2/core/types"
 )
 
 // Manager indicate manages
 // coretypes --> manager to rawparams --> plugins types
 type Manager interface {
-	AddNode(context.Context, string, types.Resources, *enginetypes.Info) (types.Resources, error)
+	AddNode(context.Context, string, resourcetypes.Resources, *enginetypes.Info) (resourcetypes.Resources, error)
 	RemoveNode(context.Context, string) error
-	GetNodesDeployCapacity(context.Context, []string, types.Resources) (map[string]*plugintypes.NodeDeployCapacity, int, error)
-	SetNodeResourceCapacity(context.Context, string, types.Resources, types.Resources, bool, bool) (types.Resources, types.Resources, error)
-	SetNodeResourceUsage(context.Context, string, types.Resources, types.Resources, []types.Resources, bool, bool) (types.Resources, types.Resources, error)
-	GetNodeResourceInfo(context.Context, string, []*types.Workload, bool) (types.Resources, types.Resources, []string, error)
+	GetNodesDeployCapacity(context.Context, []string, resourcetypes.Resources) (map[string]*plugintypes.NodeDeployCapacity, int, error)
+	SetNodeResourceCapacity(context.Context, string, resourcetypes.Resources, resourcetypes.Resources, bool, bool) (resourcetypes.Resources, resourcetypes.Resources, error)
+	SetNodeResourceUsage(context.Context, string, resourcetypes.Resources, resourcetypes.Resources, []resourcetypes.Resources, bool, bool) (resourcetypes.Resources, resourcetypes.Resources, error)
+	GetNodeResourceInfo(context.Context, string, []*types.Workload, bool) (resourcetypes.Resources, resourcetypes.Resources, []string, error)
 	GetMostIdleNode(context.Context, []string) (string, error)
 
-	Alloc(context.Context, string, int, types.Resources) ([]types.Resources, []types.Resources, error)
-	RollbackAlloc(context.Context, string, []types.Resources) error
-	Realloc(context.Context, string, types.Resources, types.Resources) (types.Resources, types.Resources, types.Resources, error)
-	RollbackRealloc(context.Context, string, types.Resources) error
-	Remap(context.Context, string, []*types.Workload) (types.Resources, error)
+	Alloc(context.Context, string, int, resourcetypes.Resources) ([]resourcetypes.Resources, []resourcetypes.Resources, error)
+	RollbackAlloc(context.Context, string, []resourcetypes.Resources) error
+	Realloc(context.Context, string, resourcetypes.Resources, resourcetypes.Resources) (resourcetypes.Resources, resourcetypes.Resources, resourcetypes.Resources, error)
+	RollbackRealloc(context.Context, string, resourcetypes.Resources) error
+	Remap(context.Context, string, []*types.Workload) (resourcetypes.Resources, error)
 
 	GetNodeMetrics(context.Context, *types.Node) ([]*plugintypes.Metrics, error)
 	GetMetricsDescription(context.Context) ([]*plugintypes.MetricsDescription, error)
diff --git a/resource/mocks/Manager.go b/resource/mocks/Manager.go
index bd7c0a9a2..ade459158 100644
--- a/resource/mocks/Manager.go
+++ b/resource/mocks/Manager.go
@@ -6,11 +6,13 @@ import (
 	context "context"
 
 	enginetypes "github.com/projecteru2/core/engine/types"
+	coretypes "github.com/projecteru2/core/types"
+
 	mock "github.com/stretchr/testify/mock"
 
 	pluginstypes "github.com/projecteru2/core/resource/plugins/types"
 
-	types "github.com/projecteru2/core/types"
+	types "github.com/projecteru2/core/resource/types"
 )
 
 // Manager is an autogenerated mock type for the Manager type
@@ -118,11 +120,11 @@ func (_m *Manager) GetMostIdleNode(_a0 context.Context, _a1 []string) (string, e
 }
 
 // GetNodeMetrics provides a mock function with given fields: _a0, _a1
-func (_m *Manager) GetNodeMetrics(_a0 context.Context, _a1 *types.Node) ([]*pluginstypes.Metrics, error) {
+func (_m *Manager) GetNodeMetrics(_a0 context.Context, _a1 *coretypes.Node) ([]*pluginstypes.Metrics, error) {
 	ret := _m.Called(_a0, _a1)
 
 	var r0 []*pluginstypes.Metrics
-	if rf, ok := ret.Get(0).(func(context.Context, *types.Node) []*pluginstypes.Metrics); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *coretypes.Node) []*pluginstypes.Metrics); ok {
 		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
@@ -131,7 +133,7 @@ func (_m *Manager) GetNodeMetrics(_a0 context.Context, _a1 *types.Node) ([]*plug
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, *types.Node) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *coretypes.Node) error); ok {
 		r1 = rf(_a0, _a1)
 	} else {
 		r1 = ret.Error(1)
@@ -141,11 +143,11 @@ func (_m *Manager) GetNodeMetrics(_a0 context.Context, _a1 *types.Node) ([]*plug
 }
 
 // GetNodeResourceInfo provides a mock function with given fields: _a0, _a1, _a2, _a3
-func (_m *Manager) GetNodeResourceInfo(_a0 context.Context, _a1 string, _a2 []*types.Workload, _a3 bool) (types.Resources, types.Resources, []string, error) {
+func (_m *Manager) GetNodeResourceInfo(_a0 context.Context, _a1 string, _a2 []*coretypes.Workload, _a3 bool) (types.Resources, types.Resources, []string, error) {
 	ret := _m.Called(_a0, _a1, _a2, _a3)
 
 	var r0 types.Resources
-	if rf, ok := ret.Get(0).(func(context.Context, string, []*types.Workload, bool) types.Resources); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, string, []*coretypes.Workload, bool) types.Resources); ok {
 		r0 = rf(_a0, _a1, _a2, _a3)
 	} else {
 		if ret.Get(0) != nil {
@@ -154,7 +156,7 @@ func (_m *Manager) GetNodeResourceInfo(_a0 context.Context, _a1 string, _a2 []*t
 	}
 
 	var r1 types.Resources
-	if rf, ok := ret.Get(1).(func(context.Context, string, []*types.Workload, bool) types.Resources); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, string, []*coretypes.Workload, bool) types.Resources); ok {
 		r1 = rf(_a0, _a1, _a2, _a3)
 	} else {
 		if ret.Get(1) != nil {
@@ -163,7 +165,7 @@ func (_m *Manager) GetNodeResourceInfo(_a0 context.Context, _a1 string, _a2 []*t
 	}
 
 	var r2 []string
-	if rf, ok := ret.Get(2).(func(context.Context, string, []*types.Workload, bool) []string); ok {
+	if rf, ok := ret.Get(2).(func(context.Context, string, []*coretypes.Workload, bool) []string); ok {
 		r2 = rf(_a0, _a1, _a2, _a3)
 	} else {
 		if ret.Get(2) != nil {
@@ -172,7 +174,7 @@ func (_m *Manager) GetNodeResourceInfo(_a0 context.Context, _a1 string, _a2 []*t
 	}
 
 	var r3 error
-	if rf, ok := ret.Get(3).(func(context.Context, string, []*types.Workload, bool) error); ok {
+	if rf, ok := ret.Get(3).(func(context.Context, string, []*coretypes.Workload, bool) error); ok {
 		r3 = rf(_a0, _a1, _a2, _a3)
 	} else {
 		r3 = ret.Error(3)
@@ -253,11 +255,11 @@ func (_m *Manager) Realloc(_a0 context.Context, _a1 string, _a2 types.Resources,
 }
 
 // Remap provides a mock function with given fields: _a0, _a1, _a2
-func (_m *Manager) Remap(_a0 context.Context, _a1 string, _a2 []*types.Workload) (types.Resources, error) {
+func (_m *Manager) Remap(_a0 context.Context, _a1 string, _a2 []*coretypes.Workload) (types.Resources, error) {
 	ret := _m.Called(_a0, _a1, _a2)
 
 	var r0 types.Resources
-	if rf, ok := ret.Get(0).(func(context.Context, string, []*types.Workload) types.Resources); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, string, []*coretypes.Workload) types.Resources); ok {
 		r0 = rf(_a0, _a1, _a2)
 	} else {
 		if ret.Get(0) != nil {
@@ -266,7 +268,7 @@ func (_m *Manager) Remap(_a0 context.Context, _a1 string, _a2 []*types.Workload)
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, string, []*types.Workload) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, string, []*coretypes.Workload) error); ok {
 		r1 = rf(_a0, _a1, _a2)
 	} else {
 		r1 = ret.Error(1)
diff --git a/resource/plugins/cpumem/types/node.go b/resource/plugins/cpumem/types/node.go
index 645a54541..83df7d4b3 100644
--- a/resource/plugins/cpumem/types/node.go
+++ b/resource/plugins/cpumem/types/node.go
@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	"github.com/mitchellh/mapstructure"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	coretypes "github.com/projecteru2/core/types"
 	coreutils "github.com/projecteru2/core/utils"
 )
@@ -20,7 +21,7 @@ type NodeResource struct {
 }
 
 // Parse .
-func (r *NodeResource) Parse(rawParams coretypes.RawParams) error {
+func (r *NodeResource) Parse(rawParams resourcetypes.RawParams) error {
 	return mapstructure.Decode(rawParams, r)
 }
 
@@ -175,7 +176,7 @@ type NodeResourceRequest struct {
 	NUMAMemory NUMAMemory `json:"numa_memory"`
 }
 
-func (n *NodeResourceRequest) Parse(config coretypes.Config, rawParams coretypes.RawParams) error {
+func (n *NodeResourceRequest) Parse(config coretypes.Config, rawParams resourcetypes.RawParams) error {
 	var err error
 
 	if n.CPUMap == nil {
@@ -232,7 +233,7 @@ func (n *NodeResourceRequest) Parse(config coretypes.Config, rawParams coretypes
 	return nil
 }
 
-func (n *NodeResourceRequest) LoadFromOrigin(nodeResource *NodeResource, rawParams coretypes.RawParams) {
+func (n *NodeResourceRequest) LoadFromOrigin(nodeResource *NodeResource, rawParams resourcetypes.RawParams) {
 	if n == nil {
 		return
 	}
diff --git a/resource/plugins/cpumem/types/workload.go b/resource/plugins/cpumem/types/workload.go
index 51e975860..2a6316939 100644
--- a/resource/plugins/cpumem/types/workload.go
+++ b/resource/plugins/cpumem/types/workload.go
@@ -3,7 +3,7 @@ package types
 import (
 	"github.com/cockroachdb/errors"
 	"github.com/mitchellh/mapstructure"
-	coretypes "github.com/projecteru2/core/types"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	coreutils "github.com/projecteru2/core/utils"
 )
 
@@ -19,7 +19,7 @@ type WorkloadResource struct {
 }
 
 // ParseFromRawParams .
-func (w *WorkloadResource) Parse(rawParams coretypes.RawParams) error {
+func (w *WorkloadResource) Parse(rawParams resourcetypes.RawParams) error {
 	return mapstructure.Decode(rawParams, w)
 }
 
@@ -113,7 +113,7 @@ func (w *WorkloadResourceRequest) Validate() error {
 }
 
 // Parse .
-func (w *WorkloadResourceRequest) Parse(rawParams coretypes.RawParams) (err error) {
+func (w *WorkloadResourceRequest) Parse(rawParams resourcetypes.RawParams) (err error) {
 	w.KeepCPUBind = rawParams.Bool("keep-cpu-bind")
 	w.CPUBind = rawParams.Bool("cpu-bind")
 
diff --git a/resource/plugins/mocks/Plugin.go b/resource/plugins/mocks/Plugin.go
index b374ab269..3edd0ab80 100644
--- a/resource/plugins/mocks/Plugin.go
+++ b/resource/plugins/mocks/Plugin.go
@@ -10,7 +10,7 @@ import (
 
 	pluginstypes "github.com/projecteru2/core/resource/plugins/types"
 
-	types "github.com/projecteru2/core/types"
+	types "github.com/projecteru2/core/resource/types"
 )
 
 // Plugin is an autogenerated mock type for the Plugin type
diff --git a/resource/plugins/types/engine.go b/resource/plugins/types/engine.go
index eb6612f92..70be30517 100644
--- a/resource/plugins/types/engine.go
+++ b/resource/plugins/types/engine.go
@@ -1,8 +1,6 @@
 package types
 
-import (
-	coretypes "github.com/projecteru2/core/types"
-)
+import resourcetypes "github.com/projecteru2/core/resource/types"
 
 // EngineParams used for engine
-type EngineParams = coretypes.RawParams
+type EngineParams = resourcetypes.RawParams
diff --git a/resource/plugins/types/node.go b/resource/plugins/types/node.go
index af34d3be7..b893e3d89 100644
--- a/resource/plugins/types/node.go
+++ b/resource/plugins/types/node.go
@@ -1,14 +1,14 @@
 package types
 
 import (
-	coretypes "github.com/projecteru2/core/types"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 )
 
 // NodeResourceRequest use for raw data to create node
-type NodeResourceRequest = coretypes.RawParams
+type NodeResourceRequest = resourcetypes.RawParams
 
 // NodeResource use for indicate node's resource
-type NodeResource = coretypes.RawParams
+type NodeResource = resourcetypes.RawParams
 
 // AddNodeResponse .
 type AddNodeResponse struct {
diff --git a/resource/plugins/types/workload.go b/resource/plugins/types/workload.go
index 14d6d0017..a6840e581 100644
--- a/resource/plugins/types/workload.go
+++ b/resource/plugins/types/workload.go
@@ -1,11 +1,9 @@
 package types
 
-import (
-	coretypes "github.com/projecteru2/core/types"
-)
+import resourcetypes "github.com/projecteru2/core/resource/types"
 
 // 带 keepbind
-type WorkloadResourceRequest = coretypes.RawParams
+type WorkloadResourceRequest = resourcetypes.RawParams
 
 // 不带 keepbind
-type WorkloadResource = coretypes.RawParams
+type WorkloadResource = resourcetypes.RawParams
diff --git a/types/resource.go b/resource/types/resource.go
similarity index 100%
rename from types/resource.go
rename to resource/types/resource.go
diff --git a/types/resource_test.go b/resource/types/resource_test.go
similarity index 100%
rename from types/resource_test.go
rename to resource/types/resource_test.go
diff --git a/rpc/transform.go b/rpc/transform.go
index 9447447e7..9f4490bdc 100644
--- a/rpc/transform.go
+++ b/rpc/transform.go
@@ -8,6 +8,7 @@ import (
 
 	enginetypes "github.com/projecteru2/core/engine/types"
 	"github.com/projecteru2/core/log"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	pb "github.com/projecteru2/core/rpc/gen"
 	"github.com/projecteru2/core/types"
 	"github.com/projecteru2/core/utils"
@@ -533,10 +534,10 @@ func toCoreRemoveImageOptions(opts *pb.RemoveImageOptions) *types.ImageOptions {
 	}
 }
 
-func toCoreResources(resources map[string][]byte) types.Resources {
-	r := types.Resources{}
+func toCoreResources(resources map[string][]byte) resourcetypes.Resources {
+	r := resourcetypes.Resources{}
 	for k, v := range resources {
-		rp := types.RawParams{}
+		rp := resourcetypes.RawParams{}
 		if err := json.Unmarshal(v, &rp); err != nil {
 			log.WithFunc("toCoreResources").Errorf(nil, err, "%v", string(v)) // nolint
 			continue
diff --git a/types/message.go b/types/message.go
index 31d3deeff..089edfaff 100644
--- a/types/message.go
+++ b/types/message.go
@@ -2,6 +2,8 @@ package types
 
 import (
 	"bytes"
+
+	resourcetypes "github.com/projecteru2/core/resource/types"
 )
 
 // RemoveWorkloadMessage for remove message
@@ -79,8 +81,8 @@ type ControlWorkloadMessage struct {
 
 // CreateWorkloadMessage for create message
 type CreateWorkloadMessage struct {
-	EngineParams Resources
-	Resources    Resources
+	EngineParams resourcetypes.Resources
+	Resources    resourcetypes.Resources
 	Podname      string
 	Nodename     string
 	WorkloadID   string
diff --git a/types/node.go b/types/node.go
index 2f004a657..f82ae5891 100644
--- a/types/node.go
+++ b/types/node.go
@@ -6,6 +6,7 @@ import (
 
 	"github.com/mitchellh/mapstructure"
 	engine "github.com/projecteru2/core/engine"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 )
 
 // NodeMeta .
@@ -27,11 +28,11 @@ func (n NodeMeta) DeepCopy() (nn NodeMeta, err error) {
 
 // NodeResourceInfo for node resource info
 type NodeResourceInfo struct {
-	Name      string      `json:"-"`
-	Capacity  Resources   `json:"capacity,omitempty"`
-	Usage     Resources   `json:"usage,omitempty"`
-	Diffs     []string    `json:"diffs,omitempty"`
-	Workloads []*Workload `json:"-"`
+	Name      string                  `json:"-"`
+	Capacity  resourcetypes.Resources `json:"capacity,omitempty"`
+	Usage     resourcetypes.Resources `json:"usage,omitempty"`
+	Diffs     []string                `json:"diffs,omitempty"`
+	Workloads []*Workload             `json:"-"`
 }
 
 // Node store node info
diff --git a/types/options.go b/types/options.go
index f36dc4ca8..ae2b0571c 100644
--- a/types/options.go
+++ b/types/options.go
@@ -3,13 +3,15 @@ package types
 import (
 	"fmt"
 	"io"
+
+	resourcetypes "github.com/projecteru2/core/resource/types"
 )
 
 // TODO should validate options
 
 // DeployOptions is options for deploying
 type DeployOptions struct {
-	Resources      Resources
+	Resources      resourcetypes.Resources
 	Name           string            // Name of application
 	Entrypoint     *Entrypoint       // entrypoint
 	Podname        string            // Name of pod to deploy
@@ -190,7 +192,7 @@ type AddNodeOptions struct {
 	Cert      string
 	Key       string
 	Labels    map[string]string
-	Resources Resources
+	Resources resourcetypes.Resources
 }
 
 // Validate checks options
@@ -212,7 +214,7 @@ type SetNodeOptions struct {
 	Nodename      string
 	Endpoint      string
 	WorkloadsDown bool
-	Resources     Resources
+	Resources     resourcetypes.Resources
 	Delta         bool
 	Labels        map[string]string
 	Bypass        TriOptions
@@ -260,7 +262,7 @@ type ExecuteWorkloadOptions struct {
 // ReallocOptions .
 type ReallocOptions struct {
 	ID        string
-	Resources Resources
+	Resources resourcetypes.Resources
 }
 
 // TriOptions .
diff --git a/types/options_test.go b/types/options_test.go
index 137999081..5f5207660 100644
--- a/types/options_test.go
+++ b/types/options_test.go
@@ -4,6 +4,7 @@ import (
 	"bufio"
 	"testing"
 
+	resourcetypes "github.com/projecteru2/core/resource/types"
 	"github.com/stretchr/testify/assert"
 	"go.uber.org/zap/buffer"
 )
@@ -17,7 +18,7 @@ func TestParseTriOption(t *testing.T) {
 
 func TestSetNodeOptions(t *testing.T) {
 	o := &SetNodeOptions{
-		Resources: Resources{},
+		Resources: resourcetypes.Resources{},
 	}
 	assert.Equal(t, ErrEmptyNodeName, o.Validate())
 
diff --git a/types/workload.go b/types/workload.go
index c605edcc5..4831e4c0d 100644
--- a/types/workload.go
+++ b/types/workload.go
@@ -6,6 +6,7 @@ import (
 
 	"github.com/projecteru2/core/engine"
 	enginetypes "github.com/projecteru2/core/engine/types"
+	resourcetypes "github.com/projecteru2/core/resource/types"
 
 	"github.com/cockroachdb/errors"
 )
@@ -35,21 +36,21 @@ type LabelMeta struct {
 // only relationship with pod and node is stored
 // if you wanna get realtime information, use Inspect method
 type Workload struct {
-	Resources    Resources         `json:"resources"`
-	EngineParams Resources         `json:"engine_params"`
-	ID           string            `json:"id"`
-	Name         string            `json:"name"`
-	Podname      string            `json:"podname"`
-	Nodename     string            `json:"nodename"`
-	Hook         *Hook             `json:"hook"`
-	Privileged   bool              `json:"privileged"`
-	User         string            `json:"user"`
-	Env          []string          `json:"env"`
-	Image        string            `json:"image"`
-	Labels       map[string]string `json:"labels"`
-	CreateTime   int64             `json:"create_time"`
-	StatusMeta   *StatusMeta       `json:"-"`
-	Engine       engine.API        `json:"-"`
+	Resources    resourcetypes.Resources `json:"resources"`
+	EngineParams resourcetypes.Resources `json:"engine_params"`
+	ID           string                  `json:"id"`
+	Name         string                  `json:"name"`
+	Podname      string                  `json:"podname"`
+	Nodename     string                  `json:"nodename"`
+	Hook         *Hook                   `json:"hook"`
+	Privileged   bool                    `json:"privileged"`
+	User         string                  `json:"user"`
+	Env          []string                `json:"env"`
+	Image        string                  `json:"image"`
+	Labels       map[string]string       `json:"labels"`
+	CreateTime   int64                   `json:"create_time"`
+	StatusMeta   *StatusMeta             `json:"-"`
+	Engine       engine.API              `json:"-"`
 }
 
 // Inspect a workload