diff --git a/.github/workflows/godoc.yml b/.github/workflows/godoc.yml
new file mode 100644
index 00000000..dfe92f98
--- /dev/null
+++ b/.github/workflows/godoc.yml
@@ -0,0 +1,69 @@
+name: godoc
+on:
+  workflow_run:
+    workflows:
+      - main
+    types:
+      - completed
+env:
+  MOD: github.com/reearth/reearth-backend
+  REPO: github.com/reearth/reearth-backend
+  REPO_NAME: reearth-backend
+  ADDR: 'localhost:8080'
+jobs:
+  godoc:
+    name: godoc
+    runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+    env:
+      DIR: ${{ github.event.workflow_run.head_branch }}
+    steps:
+      - name: set up
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.16
+        id: go
+      - name: checkout
+        uses: actions/checkout@v2
+      - name: cache
+        uses: actions/cache@v2
+        with:
+          path: ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+      - run: go mod download
+      - name: install godoc
+        run: go install golang.org/x/tools/cmd/godoc@latest
+      - name: generate docs
+        continue-on-error: true
+        run: |
+          godoc -http="$ADDR" &
+          sleep 10
+          wget -r -np -N -E -p -k "http://${ADDR}/pkg/${MOD}/"
+      - name: replace urls
+        run: |
+          [ `find . -name "*.html" -type f | wc -l` -eq 0 ] && exit 1
+          find ./${ADDR}/ -name "*.html" -print0 | xargs -0 sed -i \
+            -e "s@http://${ADDR}/src/${MOD}@https://${REPO}/blob/main@" \
+            -e "s@\"http://${ADDR}/pkg/\"@\"/${REPO_NAME}/${DIR}/pkg/${REPO}/\"@" \
+            -e 's@<form @<form style="display:none" @' \
+            -e "s@http://${ADDR}@/${REPO_NAME}/${DIR}@"
+      - name: deploy
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./${{ env.ADDR }}
+          destination_dir: ${{ env.DIR }}
+  slack-notification:
+    if: always()
+    name: Slack Notification
+    needs: godoc
+    runs-on: ubuntu-latest
+    steps:
+      - name: Slack Notification
+        uses: Gamesight/slack-workflow-status@master
+        if: always()
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          slack_webhook_url: ${{ secrets.SLACK_WEBHOOK_URL }}
diff --git a/cmd/godoc/main.go b/cmd/godoc/main.go
deleted file mode 100644
index 8fac7cf2..00000000
--- a/cmd/godoc/main.go
+++ /dev/null
@@ -1,41 +0,0 @@
-package main
-
-import (
-	"crypto/subtle"
-	"net/url"
-	"os"
-	"os/exec"
-
-	"github.com/labstack/echo/v4"
-	"github.com/labstack/echo/v4/middleware"
-)
-
-const godocPort = "8080"
-
-func main() {
-	e := echo.New()
-	err := exec.Command("godoc", "-http=:"+godocPort).Start()
-	if err != nil {
-		e.Logger.Fatal(err)
-	}
-	e.Use(middleware.Logger())
-	e.Use(middleware.Recover())
-	e.Use(middleware.BasicAuth(func(username, password string, c echo.Context) (bool, error) {
-		if subtle.ConstantTimeCompare([]byte(username), []byte(os.Getenv("BASIC_AUTH_USERNAME"))) == 1 &&
-			subtle.ConstantTimeCompare([]byte(password), []byte(os.Getenv("BASIC_AUTH_PASSWORD"))) == 1 {
-			return true, nil
-		}
-		return false, nil
-	}))
-	t, err := url.Parse("http://localhost:8080/")
-	if err != nil {
-		e.Logger.Fatal(err)
-	}
-	tl := []*middleware.ProxyTarget{
-		{
-			URL: t,
-		},
-	}
-	e.Group("", middleware.Proxy(middleware.NewRoundRobinBalancer(tl)))
-	e.Logger.Fatal(e.Start(":" + os.Getenv("PORT")))
-}
diff --git a/go.mod b/go.mod
index 2f160928..57c096f8 100644
--- a/go.mod
+++ b/go.mod
@@ -1,6 +1,5 @@
 module github.com/reearth/reearth-backend
 
-// +heroku install golang.org/x/tools/cmd/godoc
 require (
 	cloud.google.com/go v0.80.0
 	cloud.google.com/go/storage v1.14.0
diff --git a/internal/adapter/graphql/controller_project.go b/internal/adapter/graphql/controller_project.go
index 5b9711ca..1c2f66df 100644
--- a/internal/adapter/graphql/controller_project.go
+++ b/internal/adapter/graphql/controller_project.go
@@ -63,6 +63,9 @@ func (c *ProjectController) Update(ctx context.Context, ginput *UpdateProjectInp
 		Alias:             ginput.Alias,
 		ImageURL:          ginput.ImageURL,
 		Archived:          ginput.Archived,
+		IsBasicAuthActive: ginput.IsBasicAuthActive,
+		BasicAuthUsername: ginput.BasicAuthUsername,
+		BasicAuthPassword: ginput.BasicAuthPassword,
 		PublicTitle:       ginput.PublicTitle,
 		PublicDescription: ginput.PublicDescription,
 		PublicImage:       fromFile(ginput.PublicImage),
diff --git a/internal/adapter/graphql/convert_project.go b/internal/adapter/graphql/convert_project.go
index cbb69f33..138fe862 100644
--- a/internal/adapter/graphql/convert_project.go
+++ b/internal/adapter/graphql/convert_project.go
@@ -44,6 +44,9 @@ func toProject(p *project.Project) *Project {
 		ID:                p.ID().ID(),
 		CreatedAt:         p.CreatedAt(),
 		IsArchived:        p.IsArchived(),
+		IsBasicAuthActive: p.IsBasicAuthActive(),
+		BasicAuthUsername: p.BasicAuthUsername(),
+		BasicAuthPassword: p.BasicAuthPassword(),
 		Alias:             p.Alias(),
 		Name:              p.Name(),
 		Description:       p.Description(),
diff --git a/internal/adapter/graphql/convert_user.go b/internal/adapter/graphql/convert_user.go
index 68763500..02c80c8b 100644
--- a/internal/adapter/graphql/convert_user.go
+++ b/internal/adapter/graphql/convert_user.go
@@ -23,6 +23,7 @@ func toUser(user *user.User) *User {
 		Name:     user.Name(),
 		Email:    user.Email(),
 		Lang:     user.Lang(),
+		Theme:    Theme(user.Theme()),
 		MyTeamID: user.Team().ID(),
 		Auths:    authsgql,
 	}
diff --git a/internal/adapter/graphql/models_gen.go b/internal/adapter/graphql/models_gen.go
index e4dd0d55..21536f06 100644
--- a/internal/adapter/graphql/models_gen.go
+++ b/internal/adapter/graphql/models_gen.go
@@ -587,6 +587,9 @@ type PluginMetadata struct {
 type Project struct {
 	ID                id.ID             `json:"id"`
 	IsArchived        bool              `json:"isArchived"`
+	IsBasicAuthActive bool              `json:"isBasicAuthActive"`
+	BasicAuthUsername string            `json:"basicAuthUsername"`
+	BasicAuthPassword string            `json:"basicAuthPassword"`
 	CreatedAt         time.Time         `json:"createdAt"`
 	UpdatedAt         time.Time         `json:"updatedAt"`
 	PublishedAt       *time.Time        `json:"publishedAt"`
@@ -1016,6 +1019,9 @@ type UpdateProjectInput struct {
 	Name              *string         `json:"name"`
 	Description       *string         `json:"description"`
 	Archived          *bool           `json:"archived"`
+	IsBasicAuthActive *bool           `json:"isBasicAuthActive"`
+	BasicAuthUsername *string         `json:"basicAuthUsername"`
+	BasicAuthPassword *string         `json:"basicAuthPassword"`
 	Alias             *string         `json:"alias"`
 	ImageURL          *url.URL        `json:"imageUrl"`
 	PublicTitle       *string         `json:"publicTitle"`
diff --git a/internal/app/app.go b/internal/app/app.go
index f3cb0d27..160e97f5 100644
--- a/internal/app/app.go
+++ b/internal/app/app.go
@@ -132,10 +132,13 @@ func apiPublished(cfg *ServerConfig) echo.HandlerFunc {
 		}
 
 		return c.JSON(http.StatusOK, map[string]interface{}{
-			"title":       title,
-			"description": description,
-			"image":       prj.PublicImage(),
-			"noindex":     prj.PublicNoIndex(),
+			"title":             title,
+			"description":       description,
+			"image":             prj.PublicImage(),
+			"noindex":           prj.PublicNoIndex(),
+			"isBasicAuthActive": prj.IsBasicAuthActive(),
+			"basicAuthUsername": prj.BasicAuthUsername(),
+			"basicAuthPassword": prj.BasicAuthPassword(),
 		})
 	}
 }
diff --git a/internal/app/config.go b/internal/app/config.go
index 21484efd..e2a74131 100644
--- a/internal/app/config.go
+++ b/internal/app/config.go
@@ -47,12 +47,11 @@ type GCSConfig struct {
 }
 
 func ReadConfig(debug bool) (*Config, error) {
-	if debug {
-		// .env.local file is only available in debug environment
-		if err := godotenv.Load(".env.local"); err != nil && !os.IsNotExist(err) {
-			return nil, err
-		}
-		log.Infof("config: .env.local loaded")
+	// load .env
+	if err := godotenv.Load(".env"); err != nil && !os.IsNotExist(err) {
+		return nil, err
+	} else if err == nil {
+		log.Infof("config: .env loaded")
 	}
 
 	var c Config
diff --git a/internal/graphql/generated.go b/internal/graphql/generated.go
index 935017a7..01264ec5 100644
--- a/internal/graphql/generated.go
+++ b/internal/graphql/generated.go
@@ -530,11 +530,14 @@ type ComplexityRoot struct {
 
 	Project struct {
 		Alias             func(childComplexity int) int
+		BasicAuthPassword func(childComplexity int) int
+		BasicAuthUsername func(childComplexity int) int
 		CreatedAt         func(childComplexity int) int
 		Description       func(childComplexity int) int
 		ID                func(childComplexity int) int
 		ImageURL          func(childComplexity int) int
 		IsArchived        func(childComplexity int) int
+		IsBasicAuthActive func(childComplexity int) int
 		Name              func(childComplexity int) int
 		PublicDescription func(childComplexity int) int
 		PublicImage       func(childComplexity int) int
@@ -3542,6 +3545,20 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
 
 		return e.complexity.Project.Alias(childComplexity), true
 
+	case "Project.basicAuthPassword":
+		if e.complexity.Project.BasicAuthPassword == nil {
+			break
+		}
+
+		return e.complexity.Project.BasicAuthPassword(childComplexity), true
+
+	case "Project.basicAuthUsername":
+		if e.complexity.Project.BasicAuthUsername == nil {
+			break
+		}
+
+		return e.complexity.Project.BasicAuthUsername(childComplexity), true
+
 	case "Project.createdAt":
 		if e.complexity.Project.CreatedAt == nil {
 			break
@@ -3577,6 +3594,13 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
 
 		return e.complexity.Project.IsArchived(childComplexity), true
 
+	case "Project.isBasicAuthActive":
+		if e.complexity.Project.IsBasicAuthActive == nil {
+			break
+		}
+
+		return e.complexity.Project.IsBasicAuthActive(childComplexity), true
+
 	case "Project.name":
 		if e.complexity.Project.Name == nil {
 			break
@@ -5474,6 +5498,9 @@ enum Role {
 type Project implements Node {
     id: ID!
     isArchived: Boolean!
+    isBasicAuthActive: Boolean!
+    basicAuthUsername: String!
+    basicAuthPassword: String!
     createdAt: DateTime!
     updatedAt: DateTime!
     publishedAt: DateTime
@@ -6032,6 +6059,9 @@ input UpdateProjectInput {
     name: String
     description: String
     archived: Boolean
+    isBasicAuthActive: Boolean
+    basicAuthUsername: String
+    basicAuthPassword: String
     alias: String
     imageUrl: URL
     publicTitle: String
@@ -18769,6 +18799,111 @@ func (ec *executionContext) _Project_isArchived(ctx context.Context, field graph
 	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 }
 
+func (ec *executionContext) _Project_isBasicAuthActive(ctx context.Context, field graphql.CollectedField, obj *graphql1.Project) (ret graphql.Marshaler) {
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	fc := &graphql.FieldContext{
+		Object:     "Project",
+		Field:      field,
+		Args:       nil,
+		IsMethod:   false,
+		IsResolver: false,
+	}
+
+	ctx = graphql.WithFieldContext(ctx, fc)
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.IsBasicAuthActive, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(bool)
+	fc.Result = res
+	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _Project_basicAuthUsername(ctx context.Context, field graphql.CollectedField, obj *graphql1.Project) (ret graphql.Marshaler) {
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	fc := &graphql.FieldContext{
+		Object:     "Project",
+		Field:      field,
+		Args:       nil,
+		IsMethod:   false,
+		IsResolver: false,
+	}
+
+	ctx = graphql.WithFieldContext(ctx, fc)
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.BasicAuthUsername, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(string)
+	fc.Result = res
+	return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _Project_basicAuthPassword(ctx context.Context, field graphql.CollectedField, obj *graphql1.Project) (ret graphql.Marshaler) {
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	fc := &graphql.FieldContext{
+		Object:     "Project",
+		Field:      field,
+		Args:       nil,
+		IsMethod:   false,
+		IsResolver: false,
+	}
+
+	ctx = graphql.WithFieldContext(ctx, fc)
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.BasicAuthPassword, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(string)
+	fc.Result = res
+	return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
 func (ec *executionContext) _Project_createdAt(ctx context.Context, field graphql.CollectedField, obj *graphql1.Project) (ret graphql.Marshaler) {
 	defer func() {
 		if r := recover(); r != nil {
@@ -29210,6 +29345,30 @@ func (ec *executionContext) unmarshalInputUpdateProjectInput(ctx context.Context
 			if err != nil {
 				return it, err
 			}
+		case "isBasicAuthActive":
+			var err error
+
+			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("isBasicAuthActive"))
+			it.IsBasicAuthActive, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
+			if err != nil {
+				return it, err
+			}
+		case "basicAuthUsername":
+			var err error
+
+			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("basicAuthUsername"))
+			it.BasicAuthUsername, err = ec.unmarshalOString2ᚖstring(ctx, v)
+			if err != nil {
+				return it, err
+			}
+		case "basicAuthPassword":
+			var err error
+
+			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("basicAuthPassword"))
+			it.BasicAuthPassword, err = ec.unmarshalOString2ᚖstring(ctx, v)
+			if err != nil {
+				return it, err
+			}
 		case "alias":
 			var err error
 
@@ -32754,6 +32913,21 @@ func (ec *executionContext) _Project(ctx context.Context, sel ast.SelectionSet,
 			if out.Values[i] == graphql.Null {
 				atomic.AddUint32(&invalids, 1)
 			}
+		case "isBasicAuthActive":
+			out.Values[i] = ec._Project_isBasicAuthActive(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				atomic.AddUint32(&invalids, 1)
+			}
+		case "basicAuthUsername":
+			out.Values[i] = ec._Project_basicAuthUsername(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				atomic.AddUint32(&invalids, 1)
+			}
+		case "basicAuthPassword":
+			out.Values[i] = ec._Project_basicAuthPassword(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				atomic.AddUint32(&invalids, 1)
+			}
 		case "createdAt":
 			out.Values[i] = ec._Project_createdAt(ctx, field, obj)
 			if out.Values[i] == graphql.Null {
diff --git a/internal/infrastructure/mongo/mongodoc/project.go b/internal/infrastructure/mongo/mongodoc/project.go
index 6e31f7d3..d2a53ff3 100644
--- a/internal/infrastructure/mongo/mongodoc/project.go
+++ b/internal/infrastructure/mongo/mongodoc/project.go
@@ -14,6 +14,9 @@ import (
 type ProjectDocument struct {
 	ID                string
 	Archived          bool
+	IsBasicAuthActive bool
+	BasicAuthUsername string
+	BasicAuthPassword string
 	UpdatedAt         time.Time
 	PublishedAt       time.Time
 	Name              string
@@ -67,6 +70,9 @@ func NewProject(project *project.Project) (*ProjectDocument, string) {
 	return &ProjectDocument{
 		ID:                pid,
 		Archived:          project.IsArchived(),
+		IsBasicAuthActive: project.IsBasicAuthActive(),
+		BasicAuthUsername: project.BasicAuthUsername(),
+		BasicAuthPassword: project.BasicAuthPassword(),
 		UpdatedAt:         project.UpdatedAt(),
 		PublishedAt:       project.PublishedAt(),
 		Name:              project.Name(),
@@ -103,6 +109,9 @@ func (d *ProjectDocument) Model() (*project.Project, error) {
 	return project.New().
 		ID(pid).
 		IsArchived(d.Archived).
+		IsBasicAuthActive(d.IsBasicAuthActive).
+		BasicAuthUsername(d.BasicAuthUsername).
+		BasicAuthPassword(d.BasicAuthPassword).
 		UpdatedAt(d.UpdatedAt).
 		PublishedAt(d.PublishedAt).
 		Name(d.Name).
diff --git a/internal/usecase/interactor/project.go b/internal/usecase/interactor/project.go
index 8d0c914f..9f4c692f 100644
--- a/internal/usecase/interactor/project.go
+++ b/internal/usecase/interactor/project.go
@@ -169,6 +169,18 @@ func (i *Project) Update(ctx context.Context, p interfaces.UpdateProjectParam, o
 		prj.SetArchived(*p.Archived)
 	}
 
+	if p.IsBasicAuthActive != nil {
+		prj.SetIsBasicAuthActive(*p.IsBasicAuthActive)
+	}
+
+	if p.BasicAuthUsername != nil {
+		prj.SetBasicAuthUsername(*p.BasicAuthUsername)
+	}
+
+	if p.BasicAuthPassword != nil {
+		prj.SetBasicAuthPassword(*p.BasicAuthPassword)
+	}
+
 	if p.PublicTitle != nil {
 		prj.UpdatePublicTitle(*p.PublicTitle)
 	}
diff --git a/internal/usecase/interfaces/project.go b/internal/usecase/interfaces/project.go
index 24ca6960..7caa37b9 100644
--- a/internal/usecase/interfaces/project.go
+++ b/internal/usecase/interfaces/project.go
@@ -28,6 +28,9 @@ type UpdateProjectParam struct {
 	Description       *string
 	Alias             *string
 	Archived          *bool
+	IsBasicAuthActive *bool
+	BasicAuthUsername *string
+	BasicAuthPassword *string
 	ImageURL          *url.URL
 	PublicTitle       *string
 	PublicDescription *string
diff --git a/pkg/builtin/manifest.yml b/pkg/builtin/manifest.yml
index c1a9cf33..bb2dfa7e 100644
--- a/pkg/builtin/manifest.yml
+++ b/pkg/builtin/manifest.yml
@@ -139,6 +139,19 @@ extensions:
               description: "Set saturation of the fog. Min: -1 Max: 1"
               min: -1
               max: 1
+        - id: googleAnalytics
+          title: Google Analytics
+          description: Set your Google Analytics tracking ID and analyze how your published project is being viewed.
+          fields:
+            - id: enableGA
+              type: bool
+              title: Enable
+              defaultValue: false
+              description: Enable Google Analytics
+            - id: trackingId
+              type: string
+              title: Tracking ID
+              description: Paste your Google Analytics tracking ID here. This will be embedded in your published project.
   - id: infobox
     title: Infobox
     visualizer: cesium
diff --git a/pkg/builtin/manifest_gen.go b/pkg/builtin/manifest_gen.go
index 9a4ddbcb..9d09b852 100644
--- a/pkg/builtin/manifest_gen.go
+++ b/pkg/builtin/manifest_gen.go
@@ -2,4 +2,4 @@
 
 package builtin
 
-const pluginManifestJSON string = `{"author":"Re:Earth","description":"Official Plugin","extensions":[{"description":"Select here to find scene settings in the right panel. This includes setting map tiles, atmospheric conditions, real lighting, and more.","id":"cesium","schema":{"groups":[{"fields":[{"description":"The starting position of your project.","id":"camera","title":"Initial camera position","type":"camera"},{"description":"Show elevation when close to the surface.","id":"terrain","title":"Terrain","type":"bool"},{"defaultValue":true,"description":"Show the stars.","id":"skybox","title":"Sky","type":"bool"},{"description":"With Sky disabled, choose a background color.","id":"bgcolor","title":"Background color","type":"string","ui":"color"},{"description":"Cesium Ion account users may use their personal API keys to be able to use their Cesium Ion assets(tile data, 3D data, etc) with their project.","id":"ion","title":"Cesium Ion API access token","type":"string"}],"id":"default","title":"Scene"},{"description":"You may change the look of the Earth by obtaining map tile data and setting it here.","fields":[{"choices":[{"key":"default","label":"Default"},{"key":"default_label","label":"Labelled"},{"key":"default_road","label":"Road Map"},{"key":"stamen_watercolor","label":"Stamen Watercolor"},{"key":"stamen_toner","label":"Stamen Toner"},{"key":"open_street_map","label":"Open Street Map"},{"key":"esri_world_topo","label":"ESRI Topography"},{"key":"black_marble","label":"Earth at night"},{"key":"japan_gsi_standard","label":"Japan GSI Standard Map"},{"key":"url","label":"URL"}],"defaultValue":"default","id":"tile_type","title":"Tile Type","type":"string"},{"availableIf":{"field":"tile_type","type":"string","value":"url"},"id":"tile_url","title":"Tile map URL","type":"string"},{"id":"tile_minLevel","max":30,"min":0,"title":"Minimum zoom level","type":"number"},{"id":"tile_maxLevel","max":30,"min":0,"title":"Maximum zoom level","type":"number"}],"id":"tiles","list":true,"representativeField":"tile_type","title":"Tiles"},{"description":"Set the look and feel of the Earth.","fields":[{"defaultValue":true,"description":"Display the Sun.","id":"enable_sun","title":"Sun","type":"bool"},{"defaultValue":false,"description":"Display natural lighting from the sun.","id":"enable_lighting","title":"Lighting","type":"bool"},{"defaultValue":true,"description":"Display a lower atmospheric layer.","id":"ground_atmosphere","title":"Ground atmosphere","type":"bool"},{"defaultValue":true,"description":"Display an upper atmospheric layer.","id":"sky_atmosphere","title":"Sky atmosphere","type":"bool"},{"defaultValue":true,"description":"Display customizable fog.","id":"fog","title":"Fog","type":"bool"},{"defaultValue":0.0002,"description":"Set a thickness to the fog. Min: 0 Max: 1","id":"fog_density","max":1,"min":0,"title":"Fog density","type":"number"},{"defaultValue":0.03,"description":"Set brightness of the fog. Min: -1 Max: 1","id":"brightness_shift","max":1,"min":-1,"title":"Fog Brightness","type":"number"},{"description":"Set hue of the fog. Min: -1 Max: 1","id":"hue_shift","max":1,"min":-1,"title":"Fog Hue","type":"number"},{"description":"Set saturation of the fog. Min: -1 Max: 1","id":"surturation_shift","max":1,"min":-1,"title":"Fog Saturation","type":"number"}],"id":"atmosphere","title":"Atmospheric Conditions"}]},"title":"Cesium","type":"visualizer","visualizer":"cesium"},{"description":"Create an information area that appears when a layer is highlighted. Text, pictures, video, etc can be added to an infobox.","id":"infobox","schema":{"groups":[{"fields":[{"id":"title","title":"Title","type":"string"},{"choices":[{"key":"small","label":"Small"},{"key":"large","label":"Large"}],"defaultValue":"small","id":"size","title":"Size Type","type":"string"},{"id":"bgcolor","title":"Background Color","type":"string","ui":"color"},{"id":"typography","title":"Font","type":"typography"}],"id":"default","title":"Basic"}]},"title":"Infobox","type":"infobox","visualizer":"cesium"},{"description":"A standard map marker.","id":"marker","schema":{"groups":[{"fields":[{"id":"location","title":"Location","type":"latlng"},{"defaultValue":0,"id":"height","min":0,"suffix":"m","title":"Height","type":"number"},{"choices":[{"key":"point","label":"Point"},{"key":"image","label":"Icon"}],"defaultValue":"image","id":"style","title":"Style","type":"string"},{"availableIf":{"field":"style","type":"string","value":"point"},"id":"pointColor","title":"Point color","type":"string","ui":"color"},{"availableIf":{"field":"style","type":"string","value":"point"},"defaultValue":10,"id":"pointSize","min":0,"suffix":"px","title":"Point size","type":"number"},{"availableIf":{"field":"style","type":"string","value":"image"},"id":"image","title":"Image URL","type":"url","ui":"image"},{"availableIf":{"field":"style","type":"string","value":"image"},"defaultValue":1,"id":"imageSize","min":0,"title":"Image scale","type":"number"},{"availableIf":{"field":"style","type":"string","value":"image"},"choices":[{"key":"left","label":"Left"},{"key":"center","label":"Center"},{"key":"right","label":"Right"}],"defaultValue":"center","id":"imageHorizontalOrigin","title":"Image horizontal origin","type":"string"},{"availableIf":{"field":"style","type":"string","value":"image"},"choices":[{"key":"top","label":"Top"},{"key":"center","label":"Center"},{"key":"baseline","label":"Baseline"},{"key":"bottom","label":"Bottom"}],"defaultValue":"center","id":"imageVerticalOrigin","title":"Image vertical origin","type":"string"},{"availableIf":{"field":"style","type":"string","value":"image"},"choices":[{"key":"none","label":"None"},{"key":"circle","label":"Circle"}],"defaultValue":"none","id":"imageCrop","title":"Image crop","type":"string"},{"availableIf":{"field":"style","type":"string","value":"image"},"id":"imageShadow","title":"Image shadow","type":"bool"},{"availableIf":{"field":"imageShadow","type":"bool","value":true},"id":"imageShadowColor","title":"Shadow color","type":"string","ui":"color"},{"availableIf":{"field":"imageShadow","type":"bool","value":true},"defaultValue":3,"id":"imageShadowBlur","suffix":"px","title":"Shadow radius","type":"number"},{"availableIf":{"field":"imageShadow","type":"bool","value":true},"defaultValue":0,"id":"imageShadowPositionX","suffix":"px","title":"Shadow X","type":"number"},{"availableIf":{"field":"imageShadow","type":"bool","value":true},"defaultValue":0,"id":"imageShadowPositionY","suffix":"px","title":"Shadow Y","type":"number"},{"id":"label","title":"Label","type":"bool"},{"availableIf":{"field":"label","type":"bool","value":true},"id":"labelText","title":"Label text","type":"string"},{"availableIf":{"field":"label","type":"bool","value":true},"id":"labelTypography","title":"Label font","type":"typography"},{"id":"extrude","title":"Extruded","type":"bool"}],"id":"default","title":"Marker"}],"linkable":{"latlng":{"fieldId":"location","schemaGroupId":"default"},"url":{"fieldId":"image","schemaGroupId":"default"}}},"title":"Marker","type":"primitive","visualizer":"cesium"},{"description":"Polyline primitive","id":"polyline","schema":{"groups":[{"fields":[{"id":"coordinates","title":"Coordinates","type":"coordinates"},{"id":"strokeColor","title":"Stroke color","type":"string","ui":"color"},{"defaultValue":1,"id":"strokeWidth","min":0,"suffix":"px","title":"Stroke width","type":"number"}],"id":"default","title":"Polyline"}]},"title":"Polyline","type":"primitive","visualizer":"cesium"},{"description":"Polygon primitive","id":"polygon","schema":{"groups":[{"fields":[{"id":"polygon","title":"Polygon","type":"polygon"},{"defaultValue":true,"id":"fill","title":"Fill","type":"bool"},{"availableIf":{"field":"fill","type":"bool","value":true},"id":"fillColor","title":"Fill color","type":"string","ui":"color"},{"id":"stroke","title":"Stroke","type":"bool"},{"availableIf":{"field":"stroke","type":"bool","value":true},"id":"strokeColor","title":"Stroke color","type":"string","ui":"color"},{"availableIf":{"field":"stroke","type":"bool","value":true},"defaultValue":1,"id":"strokeWidth","min":0,"suffix":"px","title":"Stroke width","type":"number"}],"id":"default","title":"Polygon"}]},"title":"Polygon","type":"primitive","visualizer":"cesium"},{"description":"Rectangle primitive","id":"rect","schema":{"groups":[{"fields":[{"id":"rect","title":"Rect","type":"rect"},{"defaultValue":0,"id":"height","min":0,"suffix":"m","title":"Height","type":"number"},{"id":"extrudedHeight","min":0,"title":"Extruded height","type":"number"},{"choices":[{"key":"color","label":"Color"},{"key":"image","label":"Image"}],"defaultValue":"color","id":"style","title":"Style","type":"string"},{"availableIf":{"field":"style","type":"string","value":"color"},"id":"fillColor","title":"Fill","type":"string","ui":"color"},{"availableIf":{"field":"style","type":"string","value":"image"},"id":"image","title":"Image URL","type":"url","ui":"image"}],"id":"default","title":"Rectangle"}]},"title":"Rectangle","type":"primitive","visualizer":"cesium"},{"description":"An Icon marker that allows you to set a photo that will appear after reaching its location.","id":"photooverlay","schema":{"groups":[{"fields":[{"id":"location","title":"Location","type":"latlng"},{"id":"height","title":"Height","type":"number"},{"description":"Set the camera position for the overlay.","id":"camera","title":"Camera","type":"camera"},{"id":"image","title":"Icon","type":"url","ui":"image"},{"defaultValue":1,"id":"imageSize","prefix":"x","title":"Icon size","type":"number"},{"choices":[{"key":"left","label":"Left"},{"key":"center","label":"Center"},{"key":"right","label":"Right"}],"defaultValue":"center","id":"imageHorizontalOrigin","title":"Image horizontal origin","type":"string"},{"choices":[{"key":"top","label":"Top"},{"key":"center","label":"Center"},{"key":"baseline","label":"Baseline"},{"key":"bottom","label":"Bottom"}],"defaultValue":"center","id":"imageVerticalOrigin","title":"Image vertical origin","type":"string"},{"choices":[{"key":"none","label":"None"},{"key":"circle","label":"Circle"}],"defaultValue":"none","id":"imageCrop","title":"Icon crop","type":"string"},{"id":"imageShadow","title":"Icon shadow","type":"bool"},{"availableIf":{"field":"imageShadow","type":"bool","value":true},"id":"imageShadowColor","title":"Shadow color","type":"string","ui":"color"},{"availableIf":{"field":"imageShadow","type":"bool","value":true},"defaultValue":3,"id":"imageShadowBlur","suffix":"px","title":"Shadow radius","type":"number"},{"availableIf":{"field":"imageShadow","type":"bool","value":true},"defaultValue":0,"id":"imageShadowPositionX","suffix":"px","title":"Shadow X","type":"number"},{"availableIf":{"field":"imageShadow","type":"bool","value":true},"defaultValue":0,"id":"imageShadowPositionY","suffix":"px","title":"Shadow Y","type":"number"},{"id":"photoOverlayImage","title":"Photo","type":"url","ui":"image"},{"id":"photoOverlayDescription","title":"Photo description","type":"string","ui":"multiline"}],"id":"default","title":"Photo overlay"}],"linkable":{"latlng":{"fieldId":"location","schemaGroupId":"default"}}},"title":"Photo overlay","type":"primitive","visualizer":"cesium"},{"description":"A ball-like marker.","id":"ellipsoid","schema":{"groups":[{"fields":[{"id":"position","title":"Position","type":"latlng"},{"defaultValue":0,"id":"height","min":0,"suffix":"m","title":"Height","type":"number"},{"defaultValue":1000,"id":"radius","min":0,"suffix":"m","title":"Radius","type":"number"},{"id":"fillColor","title":"Fill","type":"string","ui":"color"}],"id":"default","title":"Ellipsoid"}],"linkable":{"latlng":{"fieldId":"position","schemaGroupId":"default"}}},"title":"Sphere","type":"primitive","visualizer":"cesium"},{"description":"Import your own primitives to be used instead of Re:Earth's built in ones.","id":"resource","schema":{"groups":[{"fields":[{"id":"url","title":"File URL","type":"url","ui":"file"},{"choices":[{"key":"auto","label":"Auto"},{"key":"kml","label":"KML"},{"key":"geojson","label":"GeoJSON / TopoJSON"},{"key":"czml","label":"CZML"}],"defaultValue":"auto","id":"type","title":"File format","type":"string"}],"id":"default","title":"File"}]},"title":"File","type":"primitive","visualizer":"cesium"},{"description":"Text block","id":"textblock","schema":{"groups":[{"fields":[{"id":"title","title":"Title","type":"string"},{"id":"text","title":"Content","type":"string","ui":"multiline"},{"id":"markdown","title":"Use markdown","type":"bool"},{"id":"typography","title":"Font","type":"typography"}],"id":"default","title":"Text block"}]},"title":"Text","type":"block","visualizer":"cesium"},{"description":"Image block","id":"imageblock","schema":{"groups":[{"fields":[{"id":"image","title":"Image","type":"url","ui":"image"},{"id":"title","title":"Title","type":"string"},{"id":"fullSize","title":"Full size","type":"bool"},{"choices":[{"key":"cover","label":"Cover"},{"key":"contain","label":"Contain"}],"defaultValue":"cover","id":"imageSize","title":"Image size","type":"string"},{"choices":[{"key":"left","label":"Left"},{"key":"center","label":"Center"},{"key":"right","label":"Right"}],"defaultValue":"center","id":"imagePositionX","title":"Image horizontal position","type":"string"},{"choices":[{"key":"top","label":"Top"},{"key":"center","label":"Center"},{"key":"bottom","label":"Bottom"}],"defaultValue":"center","id":"imagePositionY","title":"Image vertical position","type":"string"}],"id":"default","title":"Image block"}],"linkable":{"url":{"fieldId":"image","schemaGroupId":"default"}}},"title":"Image","type":"block","visualizer":"cesium"},{"description":"Video block","id":"videoblock","schema":{"groups":[{"fields":[{"id":"url","title":"Video URL","type":"url","ui":"video"},{"id":"title","title":"Title","type":"string"},{"id":"fullSize","title":"Full size","type":"bool"}],"id":"default","title":"Video block"}]},"title":"Video","type":"block","visualizer":"cesium"},{"description":"Location block","id":"locationblock","schema":{"groups":[{"fields":[{"id":"location","title":"Location","type":"latlng"},{"id":"title","title":"Title","type":"string"},{"id":"fullSize","title":"Full size","type":"bool"}],"id":"default","title":"Location block"}]},"title":"Location","type":"block","visualizer":"cesium"},{"description":"Table block","id":"dlblock","schema":{"groups":[{"fields":[{"id":"title","title":"Title","type":"string"},{"id":"typography","title":"Font","type":"typography"}],"id":"default","title":"Table block"},{"fields":[{"id":"item_title","title":"Title","type":"string"},{"choices":[{"key":"string","label":"String"},{"key":"number","label":"Number"}],"defaultValue":"string","id":"item_datatype","title":"Type","type":"string"},{"availableIf":{"field":"item_datatype","type":"string","value":"string"},"id":"item_datastr","title":"Data","type":"string"},{"availableIf":{"field":"item_datatype","type":"string","value":"number"},"id":"item_datanum","title":"Data","type":"number"}],"id":"items","list":true,"title":"Items"}]},"title":"Table","type":"block","visualizer":"cesium"},{"description":"Menu widgets","id":"menu","schema":{"groups":[{"fields":[{"id":"buttonInvisible","title":"Hide","type":"bool"},{"id":"buttonTitle","title":"Title","type":"string"},{"choices":[{"key":"topleft","label":"Top-Left"},{"key":"topright","label":"Top-Right"},{"key":"bottomleft","label":"Bottom-Left"},{"key":"bottomright","label":"Bottom-Right"}],"defaultValue":"topleft","id":"buttonPosition","title":"Position","type":"string"},{"choices":[{"key":"text","label":"Text only"},{"key":"icon","label":"Icon only"},{"key":"texticon","label":"Text and icon"}],"defaultValue":"text","id":"buttonStyle","title":"Style","type":"string"},{"id":"buttonIcon","title":"Icon","type":"url","ui":"image"},{"id":"buttonColor","title":"Text color","type":"string","ui":"color"},{"id":"buttonBgcolor","title":"Background color","type":"string","ui":"color"},{"choices":[{"key":"link","label":"Link"},{"key":"menu","label":"Menu"},{"key":"camera","label":"Camera flight"}],"defaultValue":"link","id":"buttonType","title":"Type","type":"string"},{"availableIf":{"field":"buttonType","type":"string","value":"link"},"id":"buttonLink","title":"Link","type":"url"},{"availableIf":{"field":"buttonType","type":"string","value":"camera"},"id":"buttonCamera","title":"Camera flight","type":"camera"}],"id":"buttons","list":true,"title":"Buttons"},{"fields":[{"id":"menuTitle","title":"Title","type":"string"},{"id":"menuIcon","title":"Icon","type":"url"},{"choices":[{"key":"link","label":"Link"},{"key":"camera","label":"Camera"},{"key":"border","label":"Break"}],"defaultValue":"link","id":"menuType","title":"Type","type":"string"},{"availableIf":{"field":"menuType","type":"string","value":"link"},"id":"menuLink","title":"Link","type":"url"},{"availableIf":{"field":"menuType","type":"string","value":"camera"},"id":"menuCamera","title":"Camera","type":"camera"}],"id":"menu","list":true,"title":"Menu"}]},"title":"Menu","type":"widget","visualizer":"cesium"},{"description":"A unique start screen that will display on load of your archive(ex. display the archive's title).","id":"splashscreen","schema":{"groups":[{"fields":[{"id":"overlayEnabled","title":"Enabled","type":"bool"},{"id":"overlayDelay","min":0,"suffix":"s","title":"Delay","type":"number"},{"id":"overlayDuration","min":0,"suffix":"s","title":"Duration","type":"number"},{"id":"overlayTransitionDuration","min":0,"suffix":"s","title":"Fade out","type":"number"},{"id":"overlayImage","title":"Image","type":"url","ui":"image"},{"id":"overlayImageW","title":"Image width","type":"number"},{"id":"overlayImageH","title":"Image height","type":"number"},{"id":"overlayBgcolor","title":"Background color","type":"string","ui":"color"}],"id":"overlay","title":"Overlay screen"},{"fields":[{"id":"cameraPosition","title":"Camera position","type":"camera"},{"id":"cameraDuration","min":0,"suffix":"s","title":"Duration","type":"number"},{"id":"cameraDelay","min":0,"suffix":"s","title":"Delay","type":"number"}],"id":"camera","list":true,"title":"Camera flight sequence"}]},"title":"Splash screen","type":"widget","visualizer":"cesium"},{"description":"SA feature that enables you to create a story. Connect points in a meaningful way so that your information can be consumed and understood easily.","id":"storytelling","schema":{"groups":[{"fields":[{"defaultValue":3,"id":"duration","suffix":"s","title":"Duration","type":"number"},{"defaultValue":50000,"id":"range","suffix":"m","title":"Range","type":"number"},{"id":"camera","title":"Camera pose","type":"camera","ui":"camera_pose"},{"id":"autoStart","title":"Auto start","type":"bool"}],"id":"default","title":"Storytelling"},{"fields":[{"id":"layer","title":"Layer","type":"ref","ui":"layer"},{"id":"layerDuration","suffix":"s","title":"Duration","type":"number"},{"id":"layerRange","suffix":"m","title":"Range","type":"number"},{"id":"layerCamera","title":"Camera position","type":"camera"}],"id":"stories","list":true,"representativeField":"layer","title":"Stories"}]},"title":"Storytelling","type":"widget","visualizer":"cesium"}],"id":"reearth","system":true,"title":"Re:Earth Official Plugin"}`
+const pluginManifestJSON string = `{"author":"Re:Earth","description":"Official Plugin","extensions":[{"description":"Select here to find scene settings in the right panel. This includes setting map tiles, atmospheric conditions, real lighting, and more.","id":"cesium","schema":{"groups":[{"fields":[{"description":"The starting position of your project.","id":"camera","title":"Initial camera position","type":"camera"},{"description":"Show elevation when close to the surface.","id":"terrain","title":"Terrain","type":"bool"},{"defaultValue":true,"description":"Show the stars.","id":"skybox","title":"Sky","type":"bool"},{"description":"With Sky disabled, choose a background color.","id":"bgcolor","title":"Background color","type":"string","ui":"color"},{"description":"Cesium Ion account users may use their personal API keys to be able to use their Cesium Ion assets(tile data, 3D data, etc) with their project.","id":"ion","title":"Cesium Ion API access token","type":"string"}],"id":"default","title":"Scene"},{"description":"You may change the look of the Earth by obtaining map tile data and setting it here.","fields":[{"choices":[{"key":"default","label":"Default"},{"key":"default_label","label":"Labelled"},{"key":"default_road","label":"Road Map"},{"key":"stamen_watercolor","label":"Stamen Watercolor"},{"key":"stamen_toner","label":"Stamen Toner"},{"key":"open_street_map","label":"Open Street Map"},{"key":"esri_world_topo","label":"ESRI Topography"},{"key":"black_marble","label":"Earth at night"},{"key":"japan_gsi_standard","label":"Japan GSI Standard Map"},{"key":"url","label":"URL"}],"defaultValue":"default","id":"tile_type","title":"Tile Type","type":"string"},{"availableIf":{"field":"tile_type","type":"string","value":"url"},"id":"tile_url","title":"Tile map URL","type":"string"},{"id":"tile_minLevel","max":30,"min":0,"title":"Minimum zoom level","type":"number"},{"id":"tile_maxLevel","max":30,"min":0,"title":"Maximum zoom level","type":"number"}],"id":"tiles","list":true,"representativeField":"tile_type","title":"Tiles"},{"description":"Set the look and feel of the Earth.","fields":[{"defaultValue":true,"description":"Display the Sun.","id":"enable_sun","title":"Sun","type":"bool"},{"defaultValue":false,"description":"Display natural lighting from the sun.","id":"enable_lighting","title":"Lighting","type":"bool"},{"defaultValue":true,"description":"Display a lower atmospheric layer.","id":"ground_atmosphere","title":"Ground atmosphere","type":"bool"},{"defaultValue":true,"description":"Display an upper atmospheric layer.","id":"sky_atmosphere","title":"Sky atmosphere","type":"bool"},{"defaultValue":true,"description":"Display customizable fog.","id":"fog","title":"Fog","type":"bool"},{"defaultValue":0.0002,"description":"Set a thickness to the fog. Min: 0 Max: 1","id":"fog_density","max":1,"min":0,"title":"Fog density","type":"number"},{"defaultValue":0.03,"description":"Set brightness of the fog. Min: -1 Max: 1","id":"brightness_shift","max":1,"min":-1,"title":"Fog Brightness","type":"number"},{"description":"Set hue of the fog. Min: -1 Max: 1","id":"hue_shift","max":1,"min":-1,"title":"Fog Hue","type":"number"},{"description":"Set saturation of the fog. Min: -1 Max: 1","id":"surturation_shift","max":1,"min":-1,"title":"Fog Saturation","type":"number"}],"id":"atmosphere","title":"Atmospheric Conditions"},{"description":"Set your Google Analytics tracking ID and analyze how your published project is being viewed.","fields":[{"defaultValue":false,"description":"Enable Google Analytics","id":"enableGA","title":"Enable","type":"bool"},{"description":"Paste your Google Analytics tracking ID here. This will be embedded in your published project.","id":"trackingId","title":"Tracking ID","type":"string"}],"id":"googleAnalytics","title":"Google Analytics"}]},"title":"Cesium","type":"visualizer","visualizer":"cesium"},{"description":"Create an information area that appears when a layer is highlighted. Text, pictures, video, etc can be added to an infobox.","id":"infobox","schema":{"groups":[{"fields":[{"id":"title","title":"Title","type":"string"},{"choices":[{"key":"small","label":"Small"},{"key":"large","label":"Large"}],"defaultValue":"small","id":"size","title":"Size Type","type":"string"},{"id":"bgcolor","title":"Background Color","type":"string","ui":"color"},{"id":"typography","title":"Font","type":"typography"}],"id":"default","title":"Basic"}]},"title":"Infobox","type":"infobox","visualizer":"cesium"},{"description":"A standard map marker.","id":"marker","schema":{"groups":[{"fields":[{"id":"location","title":"Location","type":"latlng"},{"defaultValue":0,"id":"height","min":0,"suffix":"m","title":"Height","type":"number"},{"choices":[{"key":"point","label":"Point"},{"key":"image","label":"Icon"}],"defaultValue":"image","id":"style","title":"Style","type":"string"},{"availableIf":{"field":"style","type":"string","value":"point"},"id":"pointColor","title":"Point color","type":"string","ui":"color"},{"availableIf":{"field":"style","type":"string","value":"point"},"defaultValue":10,"id":"pointSize","min":0,"suffix":"px","title":"Point size","type":"number"},{"availableIf":{"field":"style","type":"string","value":"image"},"id":"image","title":"Image URL","type":"url","ui":"image"},{"availableIf":{"field":"style","type":"string","value":"image"},"defaultValue":1,"id":"imageSize","min":0,"title":"Image scale","type":"number"},{"availableIf":{"field":"style","type":"string","value":"image"},"choices":[{"key":"left","label":"Left"},{"key":"center","label":"Center"},{"key":"right","label":"Right"}],"defaultValue":"center","id":"imageHorizontalOrigin","title":"Image horizontal origin","type":"string"},{"availableIf":{"field":"style","type":"string","value":"image"},"choices":[{"key":"top","label":"Top"},{"key":"center","label":"Center"},{"key":"baseline","label":"Baseline"},{"key":"bottom","label":"Bottom"}],"defaultValue":"center","id":"imageVerticalOrigin","title":"Image vertical origin","type":"string"},{"availableIf":{"field":"style","type":"string","value":"image"},"choices":[{"key":"none","label":"None"},{"key":"circle","label":"Circle"}],"defaultValue":"none","id":"imageCrop","title":"Image crop","type":"string"},{"availableIf":{"field":"style","type":"string","value":"image"},"id":"imageShadow","title":"Image shadow","type":"bool"},{"availableIf":{"field":"imageShadow","type":"bool","value":true},"id":"imageShadowColor","title":"Shadow color","type":"string","ui":"color"},{"availableIf":{"field":"imageShadow","type":"bool","value":true},"defaultValue":3,"id":"imageShadowBlur","suffix":"px","title":"Shadow radius","type":"number"},{"availableIf":{"field":"imageShadow","type":"bool","value":true},"defaultValue":0,"id":"imageShadowPositionX","suffix":"px","title":"Shadow X","type":"number"},{"availableIf":{"field":"imageShadow","type":"bool","value":true},"defaultValue":0,"id":"imageShadowPositionY","suffix":"px","title":"Shadow Y","type":"number"},{"id":"label","title":"Label","type":"bool"},{"availableIf":{"field":"label","type":"bool","value":true},"id":"labelText","title":"Label text","type":"string"},{"availableIf":{"field":"label","type":"bool","value":true},"id":"labelTypography","title":"Label font","type":"typography"},{"id":"extrude","title":"Extruded","type":"bool"}],"id":"default","title":"Marker"}],"linkable":{"latlng":{"fieldId":"location","schemaGroupId":"default"},"url":{"fieldId":"image","schemaGroupId":"default"}}},"title":"Marker","type":"primitive","visualizer":"cesium"},{"description":"Polyline primitive","id":"polyline","schema":{"groups":[{"fields":[{"id":"coordinates","title":"Coordinates","type":"coordinates"},{"id":"strokeColor","title":"Stroke color","type":"string","ui":"color"},{"defaultValue":1,"id":"strokeWidth","min":0,"suffix":"px","title":"Stroke width","type":"number"}],"id":"default","title":"Polyline"}]},"title":"Polyline","type":"primitive","visualizer":"cesium"},{"description":"Polygon primitive","id":"polygon","schema":{"groups":[{"fields":[{"id":"polygon","title":"Polygon","type":"polygon"},{"defaultValue":true,"id":"fill","title":"Fill","type":"bool"},{"availableIf":{"field":"fill","type":"bool","value":true},"id":"fillColor","title":"Fill color","type":"string","ui":"color"},{"id":"stroke","title":"Stroke","type":"bool"},{"availableIf":{"field":"stroke","type":"bool","value":true},"id":"strokeColor","title":"Stroke color","type":"string","ui":"color"},{"availableIf":{"field":"stroke","type":"bool","value":true},"defaultValue":1,"id":"strokeWidth","min":0,"suffix":"px","title":"Stroke width","type":"number"}],"id":"default","title":"Polygon"}]},"title":"Polygon","type":"primitive","visualizer":"cesium"},{"description":"Rectangle primitive","id":"rect","schema":{"groups":[{"fields":[{"id":"rect","title":"Rect","type":"rect"},{"defaultValue":0,"id":"height","min":0,"suffix":"m","title":"Height","type":"number"},{"id":"extrudedHeight","min":0,"title":"Extruded height","type":"number"},{"choices":[{"key":"color","label":"Color"},{"key":"image","label":"Image"}],"defaultValue":"color","id":"style","title":"Style","type":"string"},{"availableIf":{"field":"style","type":"string","value":"color"},"id":"fillColor","title":"Fill","type":"string","ui":"color"},{"availableIf":{"field":"style","type":"string","value":"image"},"id":"image","title":"Image URL","type":"url","ui":"image"}],"id":"default","title":"Rectangle"}]},"title":"Rectangle","type":"primitive","visualizer":"cesium"},{"description":"An Icon marker that allows you to set a photo that will appear after reaching its location.","id":"photooverlay","schema":{"groups":[{"fields":[{"id":"location","title":"Location","type":"latlng"},{"id":"height","title":"Height","type":"number"},{"description":"Set the camera position for the overlay.","id":"camera","title":"Camera","type":"camera"},{"id":"image","title":"Icon","type":"url","ui":"image"},{"defaultValue":1,"id":"imageSize","prefix":"x","title":"Icon size","type":"number"},{"choices":[{"key":"left","label":"Left"},{"key":"center","label":"Center"},{"key":"right","label":"Right"}],"defaultValue":"center","id":"imageHorizontalOrigin","title":"Image horizontal origin","type":"string"},{"choices":[{"key":"top","label":"Top"},{"key":"center","label":"Center"},{"key":"baseline","label":"Baseline"},{"key":"bottom","label":"Bottom"}],"defaultValue":"center","id":"imageVerticalOrigin","title":"Image vertical origin","type":"string"},{"choices":[{"key":"none","label":"None"},{"key":"circle","label":"Circle"}],"defaultValue":"none","id":"imageCrop","title":"Icon crop","type":"string"},{"id":"imageShadow","title":"Icon shadow","type":"bool"},{"availableIf":{"field":"imageShadow","type":"bool","value":true},"id":"imageShadowColor","title":"Shadow color","type":"string","ui":"color"},{"availableIf":{"field":"imageShadow","type":"bool","value":true},"defaultValue":3,"id":"imageShadowBlur","suffix":"px","title":"Shadow radius","type":"number"},{"availableIf":{"field":"imageShadow","type":"bool","value":true},"defaultValue":0,"id":"imageShadowPositionX","suffix":"px","title":"Shadow X","type":"number"},{"availableIf":{"field":"imageShadow","type":"bool","value":true},"defaultValue":0,"id":"imageShadowPositionY","suffix":"px","title":"Shadow Y","type":"number"},{"id":"photoOverlayImage","title":"Photo","type":"url","ui":"image"},{"id":"photoOverlayDescription","title":"Photo description","type":"string","ui":"multiline"}],"id":"default","title":"Photo overlay"}],"linkable":{"latlng":{"fieldId":"location","schemaGroupId":"default"}}},"title":"Photo overlay","type":"primitive","visualizer":"cesium"},{"description":"A ball-like marker.","id":"ellipsoid","schema":{"groups":[{"fields":[{"id":"position","title":"Position","type":"latlng"},{"defaultValue":0,"id":"height","min":0,"suffix":"m","title":"Height","type":"number"},{"defaultValue":1000,"id":"radius","min":0,"suffix":"m","title":"Radius","type":"number"},{"id":"fillColor","title":"Fill","type":"string","ui":"color"}],"id":"default","title":"Ellipsoid"}],"linkable":{"latlng":{"fieldId":"position","schemaGroupId":"default"}}},"title":"Sphere","type":"primitive","visualizer":"cesium"},{"description":"Import your own primitives to be used instead of Re:Earth's built in ones.","id":"resource","schema":{"groups":[{"fields":[{"id":"url","title":"File URL","type":"url","ui":"file"},{"choices":[{"key":"auto","label":"Auto"},{"key":"kml","label":"KML"},{"key":"geojson","label":"GeoJSON / TopoJSON"},{"key":"czml","label":"CZML"}],"defaultValue":"auto","id":"type","title":"File format","type":"string"}],"id":"default","title":"File"}]},"title":"File","type":"primitive","visualizer":"cesium"},{"description":"Text block","id":"textblock","schema":{"groups":[{"fields":[{"id":"title","title":"Title","type":"string"},{"id":"text","title":"Content","type":"string","ui":"multiline"},{"id":"markdown","title":"Use markdown","type":"bool"},{"id":"typography","title":"Font","type":"typography"}],"id":"default","title":"Text block"}]},"title":"Text","type":"block","visualizer":"cesium"},{"description":"Image block","id":"imageblock","schema":{"groups":[{"fields":[{"id":"image","title":"Image","type":"url","ui":"image"},{"id":"title","title":"Title","type":"string"},{"id":"fullSize","title":"Full size","type":"bool"},{"choices":[{"key":"cover","label":"Cover"},{"key":"contain","label":"Contain"}],"defaultValue":"cover","id":"imageSize","title":"Image size","type":"string"},{"choices":[{"key":"left","label":"Left"},{"key":"center","label":"Center"},{"key":"right","label":"Right"}],"defaultValue":"center","id":"imagePositionX","title":"Image horizontal position","type":"string"},{"choices":[{"key":"top","label":"Top"},{"key":"center","label":"Center"},{"key":"bottom","label":"Bottom"}],"defaultValue":"center","id":"imagePositionY","title":"Image vertical position","type":"string"}],"id":"default","title":"Image block"}],"linkable":{"url":{"fieldId":"image","schemaGroupId":"default"}}},"title":"Image","type":"block","visualizer":"cesium"},{"description":"Video block","id":"videoblock","schema":{"groups":[{"fields":[{"id":"url","title":"Video URL","type":"url","ui":"video"},{"id":"title","title":"Title","type":"string"},{"id":"fullSize","title":"Full size","type":"bool"}],"id":"default","title":"Video block"}]},"title":"Video","type":"block","visualizer":"cesium"},{"description":"Location block","id":"locationblock","schema":{"groups":[{"fields":[{"id":"location","title":"Location","type":"latlng"},{"id":"title","title":"Title","type":"string"},{"id":"fullSize","title":"Full size","type":"bool"}],"id":"default","title":"Location block"}]},"title":"Location","type":"block","visualizer":"cesium"},{"description":"Table block","id":"dlblock","schema":{"groups":[{"fields":[{"id":"title","title":"Title","type":"string"},{"id":"typography","title":"Font","type":"typography"}],"id":"default","title":"Table block"},{"fields":[{"id":"item_title","title":"Title","type":"string"},{"choices":[{"key":"string","label":"String"},{"key":"number","label":"Number"}],"defaultValue":"string","id":"item_datatype","title":"Type","type":"string"},{"availableIf":{"field":"item_datatype","type":"string","value":"string"},"id":"item_datastr","title":"Data","type":"string"},{"availableIf":{"field":"item_datatype","type":"string","value":"number"},"id":"item_datanum","title":"Data","type":"number"}],"id":"items","list":true,"title":"Items"}]},"title":"Table","type":"block","visualizer":"cesium"},{"description":"Menu widgets","id":"menu","schema":{"groups":[{"fields":[{"id":"buttonInvisible","title":"Hide","type":"bool"},{"id":"buttonTitle","title":"Title","type":"string"},{"choices":[{"key":"topleft","label":"Top-Left"},{"key":"topright","label":"Top-Right"},{"key":"bottomleft","label":"Bottom-Left"},{"key":"bottomright","label":"Bottom-Right"}],"defaultValue":"topleft","id":"buttonPosition","title":"Position","type":"string"},{"choices":[{"key":"text","label":"Text only"},{"key":"icon","label":"Icon only"},{"key":"texticon","label":"Text and icon"}],"defaultValue":"text","id":"buttonStyle","title":"Style","type":"string"},{"id":"buttonIcon","title":"Icon","type":"url","ui":"image"},{"id":"buttonColor","title":"Text color","type":"string","ui":"color"},{"id":"buttonBgcolor","title":"Background color","type":"string","ui":"color"},{"choices":[{"key":"link","label":"Link"},{"key":"menu","label":"Menu"},{"key":"camera","label":"Camera flight"}],"defaultValue":"link","id":"buttonType","title":"Type","type":"string"},{"availableIf":{"field":"buttonType","type":"string","value":"link"},"id":"buttonLink","title":"Link","type":"url"},{"availableIf":{"field":"buttonType","type":"string","value":"camera"},"id":"buttonCamera","title":"Camera flight","type":"camera"}],"id":"buttons","list":true,"title":"Buttons"},{"fields":[{"id":"menuTitle","title":"Title","type":"string"},{"id":"menuIcon","title":"Icon","type":"url"},{"choices":[{"key":"link","label":"Link"},{"key":"camera","label":"Camera"},{"key":"border","label":"Break"}],"defaultValue":"link","id":"menuType","title":"Type","type":"string"},{"availableIf":{"field":"menuType","type":"string","value":"link"},"id":"menuLink","title":"Link","type":"url"},{"availableIf":{"field":"menuType","type":"string","value":"camera"},"id":"menuCamera","title":"Camera","type":"camera"}],"id":"menu","list":true,"title":"Menu"}]},"title":"Menu","type":"widget","visualizer":"cesium"},{"description":"A unique start screen that will display on load of your archive(ex. display the archive's title).","id":"splashscreen","schema":{"groups":[{"fields":[{"id":"overlayEnabled","title":"Enabled","type":"bool"},{"id":"overlayDelay","min":0,"suffix":"s","title":"Delay","type":"number"},{"id":"overlayDuration","min":0,"suffix":"s","title":"Duration","type":"number"},{"id":"overlayTransitionDuration","min":0,"suffix":"s","title":"Fade out","type":"number"},{"id":"overlayImage","title":"Image","type":"url","ui":"image"},{"id":"overlayImageW","title":"Image width","type":"number"},{"id":"overlayImageH","title":"Image height","type":"number"},{"id":"overlayBgcolor","title":"Background color","type":"string","ui":"color"}],"id":"overlay","title":"Overlay screen"},{"fields":[{"id":"cameraPosition","title":"Camera position","type":"camera"},{"id":"cameraDuration","min":0,"suffix":"s","title":"Duration","type":"number"},{"id":"cameraDelay","min":0,"suffix":"s","title":"Delay","type":"number"}],"id":"camera","list":true,"title":"Camera flight sequence"}]},"title":"Splash screen","type":"widget","visualizer":"cesium"},{"description":"SA feature that enables you to create a story. Connect points in a meaningful way so that your information can be consumed and understood easily.","id":"storytelling","schema":{"groups":[{"fields":[{"defaultValue":3,"id":"duration","suffix":"s","title":"Duration","type":"number"},{"defaultValue":50000,"id":"range","suffix":"m","title":"Range","type":"number"},{"id":"camera","title":"Camera pose","type":"camera","ui":"camera_pose"},{"id":"autoStart","title":"Auto start","type":"bool"}],"id":"default","title":"Storytelling"},{"fields":[{"id":"layer","title":"Layer","type":"ref","ui":"layer"},{"id":"layerDuration","suffix":"s","title":"Duration","type":"number"},{"id":"layerRange","suffix":"m","title":"Range","type":"number"},{"id":"layerCamera","title":"Camera position","type":"camera"}],"id":"stories","list":true,"representativeField":"layer","title":"Stories"}]},"title":"Storytelling","type":"widget","visualizer":"cesium"}],"id":"reearth","system":true,"title":"Re:Earth Official Plugin"}`
diff --git a/pkg/builtin/manifest_ja.yml b/pkg/builtin/manifest_ja.yml
index 5588e390..84313ac8 100644
--- a/pkg/builtin/manifest_ja.yml
+++ b/pkg/builtin/manifest_ja.yml
@@ -76,6 +76,16 @@ extensions:
             title: 色相
           surturation_shift:
             title: 彩度
+      googleAnalytics:
+        title: Google Analytics
+        description: Google Analyticsを有効にすることで、公開ページがどのように閲覧されているかを分析することが可能です。
+        fields:
+          enableGA:
+            title: 有効
+            description: Google Analyticsを有効にします。
+          trackingCode:
+            title: トラッキングID
+            description: ここにグーグルアナリティクスのトラッキングIDを貼り付けることで、公開プロジェクトにこのコードが埋め込まれます。
   infobox:
     title: インフォボックス
     description: 閲覧者が地図上のレイヤーをクリックした時に表示されるボックスです。テキストや画像、動画などのコンテンツを表示することができます。
diff --git a/pkg/builtin/manifest_ja_gen.go b/pkg/builtin/manifest_ja_gen.go
index 1ba2a559..85079918 100644
--- a/pkg/builtin/manifest_ja_gen.go
+++ b/pkg/builtin/manifest_ja_gen.go
@@ -2,4 +2,4 @@
 
 package builtin
 
-const pluginManifestJSON_ja string = `{"description":"公式プラグイン","extensions":{"cesium":{"description":"右パネルでシーン全体の設定を変更することができます。タイル、大気、ライティングなどの設定が含まれています。","propertySchema":{"atmosphere":{"description":"地球を覆う大気圏の設定ができます。","fields":{"brightness_shift":{"title":"明度"},"enable_lighting":{"description":"太陽光のON/OFFを切り替えることで、昼夜を表現することができます。","title":"太陽光"},"enable_sun":{"description":"宇宙空間に存在する太陽の表示を切り替えます。","title":"太陽"},"fog":{"description":"霧のON/OFFを切り替えます。","title":"霧"},"fog_density":{"description":"霧の濃度を0以上から設定します。","title":"濃度"},"ground_atmosphere":{"description":"地表の大気圏のON/OFFを切り替えます。","title":"地表の大気"},"hue_shift":{"title":"色相"},"sky_atmosphere":{"description":"地球を覆う大気圏のON/OFFを切り替えます。","title":"上空の大気"},"surturation_shift":{"title":"彩度"}},"title":"大気"},"default":{"fields":{"bgcolor":{"description":"宇宙空間が非表示の場合の、背景色を設定します。","title":"背景色"},"camera":{"description":"ページロード後最初に表示するカメラの位置を設定します。","title":"カメラ初期位置"},"ion":{"description":"自身のCesium IonアカウントからAPIキーを発行し、ここに設定します。Cesium Ionのアセット（タイルデータ、3Dデータなど）の使用が可能になるため、設定を推奨します。","title":"Cesium Icon APIアクセストークン"},"skybox":{"description":"宇宙空間の表示を切り替えます。","title":"宇宙の表示"},"terrain":{"description":"有効にすると、標高データが読み込みこまれ、立体的な地形を表現することができます。","title":"地形"}},"title":"シーン"},"tiles":{"description":"手持ちのタイルデータを使用し、地球上に表示することができます。","fields":{"tile_maxLevel":{"title":"最大レベル"},"tile_minLevel":{"title":"最小レベル"},"tile_title":{"title":"名前"},"tile_type":{"choices":{"black_marble":"Black Marble","default":"デフォルト","default_label":"ラベル付き地図","default_road":"道路地図","esri_world_topo":"ESRI Topography","japan_gsi_standard":"地理院地図 標準地図","open_street_map":"Open Street Map","stamen_toner":"Stamen Toner","stamen_watercolor":"Stamen Watercolor","url":"URL"},"title":"種類"},"tile_url":{"title":"URL"}},"title":"タイル"}},"title":"Cesium"},"dlblock":{"description":"表ブロック","propertySchema":{"default":{"fields":{"title":{"title":"タイトル"},"typography":{"title":"フォント"}},"title":"表ブロック"},"items":{"fields":{"item_datanum":{"title":"データ(数字)"},"item_datastr":{"title":"データ(文字)"},"item_datatype":{"choices":{"number":"数字","string":"文字"},"title":"種類"},"item_title":{"title":"タイトル"}},"title":"アイテム"}},"title":"表"},"ellipsoid":{"description":"楕円形ツールを地図上にドラッグ\u0026ドロップすることで追加できます。楕円形ツールによって立体的なオブジェクトを地図上に表示できます。","propertySchema":{"default":{"fields":{"fillColor":{"title":"塗り色"},"height":{"title":"高度"},"position":{"title":"位置"},"radius":{"title":"半径"}},"title":"球体ツール"}},"title":"球体ツール"},"imageblock":{"description":"画像ブロック","propertySchema":{"default":{"fields":{"fullSize":{"title":"フルサイズ"},"image":{"title":"画像"},"imagePositionX":{"choices":{"center":"中央","left":"左","right":"右"},"title":"水平位置"},"imagePositionY":{"choices":{"bottom":"下","center":"中央","top":"上"},"title":"垂直位置"},"imageSize":{"choices":{"contain":"含む","cover":"カバー"},"title":"画像サイズ"},"title":{"title":"タイトル"}},"title":"画像ブロック"}},"title":"画像"},"infobox":{"description":"閲覧者が地図上のレイヤーをクリックした時に表示されるボックスです。テキストや画像、動画などのコンテンツを表示することができます。","propertySchema":{"default":{"fields":{"bgcolor":{"title":"背景色"},"size":{"choices":{"large":"大","small":"小"},"title":"サイズ"},"title":{"title":"タイトル"},"typography":{"title":"フォント"}},"title":"インフォボックス"}},"title":"インフォボックス"},"locationblock":{"description":"位置情報ブロック","propertySchema":{"default":{"fields":{"fullSize":{"title":"フルサイズ"},"location":{"title":"位置情報"},"title":{"title":"タイトル"}},"title":"位置情報ブロック"}},"title":"位置情報"},"marker":{"description":"ドラッグ\u0026ドロップすることで、地図上にマーカーを追加します。マーカーにはテキストや画像を紐づけることができ、閲覧者はマーカーをクリックすることでそれらのコンテンツを見ることができます。","propertySchema":{"default":{"fields":{"extrude":{"title":"地面から線を伸ばす"},"height":{"title":"高度"},"image":{"title":"画像URL"},"imageCrop":{"choices":{"circle":"円形","none":"なし"},"title":"切り抜き"},"imageShadow":{"title":"シャドウ"},"imageShadowBlur":{"title":"シャドウ半径"},"imageShadowColor":{"title":"シャドウ色"},"imageShadowPositionX":{"title":"シャドウX"},"imageShadowPositionY":{"title":"シャドウY"},"imageSize":{"title":"画像サイズ"},"label":{"title":"ラベル"},"labelText":{"title":"ラベル文字"},"labelTypography":{"title":"ラベルフォント"},"location":{"title":"位置"},"pointColor":{"title":"ポイント色"},"pointSize":{"title":"ポイントサイズ"},"style":{"choices":{"image":"アイコン","point":"ポイント"},"title":"表示方法"}},"title":"マーカー"}},"title":"マーカー"},"menu":{"description":"シーンにボタンを設置し、メニューを表示します。追加したボタンに設定されたアクションタイプによって動作が変わります。\\n・リンク：ボタン自体が外部サイトへのリンクになります。\\n・メニュー：追加したメニューを開きます\\n・カメラアクション：クリック時にカメラを移動します。","propertySchema":{"buttons":{"fields":{"buttonBgcolor":{"title":"背景色"},"buttonCamera":{"title":"カメラ"},"buttonColor":{"title":"テキスト色"},"buttonIcon":{"title":"アイコン"},"buttonInvisible":{"title":"非表示"},"buttonLink":{"title":"リンク"},"buttonPosition":{"choices":{"bottomleft":"下左","bottomright":"下右","topleft":"上左","topright":"上右"},"title":"表示位置"},"buttonStyle":{"choices":{"icon":"アイコンのみ","text":"テキストのみ","texticon":"テキスト＋アイコン"},"title":"表示方法"},"buttonTitle":{"title":"タイトル"},"buttonType":{"choices":{"camera":"カメラ移動","link":"リンク","menu":"メニュー開閉"},"title":"アクション"}},"title":"ボタン"},"menu":{"fields":{"menuCamera":{"title":"カメラ"},"menuIcon":{"title":"アイコン"},"menuLink":{"title":"リンク"},"menuTitle":{"title":"タイトル"},"menuType":{"choices":{"border":"区切り線","camera":"カメラ移動","link":"リンク"},"title":"アクション"}},"title":"メニュー"}},"title":"メニュー"},"photooverlay":{"description":"地図上に追加されたフォトオーバーレイを選択すると、設定した画像をモーダル形式で表示することができます。","propertySchema":{"default":{"fields":{"camera":{"description":"クリックされたときに移動するカメラの設定をします。","title":"カメラ"},"height":{"title":"高度"},"image":{"title":"アイコン"},"imageCrop":{"choices":{"circle":"円形","none":"なし"},"title":"切り抜き"},"imageShadow":{"title":"アイコンシャドウ"},"imageShadowBlur":{"title":"シャドウ半径"},"imageShadowColor":{"title":"シャドウ色"},"imageShadowPositionX":{"title":"シャドウX"},"imageShadowPositionY":{"title":"シャドウY"},"imageSize":{"title":"アイコンサイズ"},"location":{"title":"位置"},"photoOverlayImage":{"title":"オーバレイ画像"}},"title":"フォトオーバーレイ"}},"title":"フォトオーバーレイ"},"polygon":{"description":"Polygon primitive","propertySchema":{"default":{"fields":{"fill":{"title":"塗り"},"fillColor":{"title":"塗り色"},"polygon":{"title":"ポリゴン"},"stroke":{"title":"線"},"strokeColor":{"title":"線色"},"strokeWidth":{"title":"線幅"}},"title":"ポリゴン"}},"title":"ポリゴン"},"polyline":{"description":"Polyline primitive","propertySchema":{"default":{"fields":{"coordinates":{"title":"頂点"},"strokeColor":{"title":"線色"},"strokeWidth":{"title":"線幅"}},"title":"直線"}},"title":"直線"},"rect":{"description":"Rectangle primitive","propertySchema":{"default":{"fields":{"extrudedHeight":{"title":"高さ"},"fillColor":{"title":"塗り色"},"height":{"title":"高度"},"image":{"title":"画像URL"},"rect":{"title":"長方形"},"style":{"choices":{"color":"色","image":"画像"},"title":"スタイル"}},"title":"長方形"}},"title":"長方形"},"resource":{"description":"外部からデータ（形式何？？？）をインポートすることができます。地図上に追加後、URLを指定することで外部データが読み込まれます。","propertySchema":{"default":{"fields":{"url":{"choices":{"auto":"自動","czml":"CZML","geojson":"GeoJSON / TopoJSON","kml":"KML"},"title":"ファイル URL"}},"title":"ファイル"}},"title":"ファイル"},"splashscreen":{"description":"ページロード後、最初に表示される演出を設定できます。例えば、プロジェクトのタイトルを閲覧者に見せたり、カメラを移動させることができます。","propertySchema":{"camera":{"fields":{"cameraDelay":{"title":"カメラ移動時間"},"cameraDuration":{"title":"カメラ開始時間"},"cameraPosition":{"title":"カメラ位置"}},"title":"カメラアニメーション"},"overlay":{"fields":{"overlayBgcolor":{"title":"背景色"},"overlayDelay":{"title":"開始時間"},"overlayDuration":{"title":"表示時間"},"overlayEnabled":{"title":"有効"},"overlayImage":{"title":"オーバーレイ画像"},"overlayImageH":{"title":"画像高さ"},"overlayImageW":{"title":"画像幅"},"overlayTransitionDuration":{"title":"フェード時間"}},"title":"オーバーレイ"}},"title":"スプラッシュスクリーン"},"storytelling":{"description":"ストーリーテリング機能を使えば、データ間の繋がりや時系列をもとに、順番に資料を閲覧してもらうことが可能です。使用するには、右パネルから地球上のレイヤーに順番を付与します。","propertySchema":{"default":{"fields":{"autoStart":{"title":"自動再生"},"camera":{"title":"カメラ"},"duration":{"title":"カメラ移動時間"},"range":{"title":"画角"}},"title":"デフォルト"},"stories":{"fields":{"layer":{"title":"レイヤー"},"layerCamera":{"title":"カメラ"},"layerDuration":{"title":"移動時間"},"layerRange":{"title":"カメラ画角"}},"title":"ストーリー"}},"title":"ストーリーテリング"},"textblock":{"description":"Text block","propertySchema":{"default":{"fields":{"markdown":{"title":"マークダウン"},"text":{"title":"コンテンツ"},"title":{"title":"タイトル"},"typography":{"title":"フォント"}},"title":"テキストブロック"}},"title":"テキスト"},"videoblock":{"description":"動画ブロック","propertySchema":{"default":{"fields":{"fullSize":{"title":"フルサイズ"},"title":{"title":"タイトル"},"url":{"title":"動画 URL"}},"title":"動画ブロック"}},"title":"動画"}},"title":"Re:Earth公式プラグイン"}`
+const pluginManifestJSON_ja string = `{"description":"公式プラグイン","extensions":{"cesium":{"description":"右パネルでシーン全体の設定を変更することができます。タイル、大気、ライティングなどの設定が含まれています。","propertySchema":{"atmosphere":{"description":"地球を覆う大気圏の設定ができます。","fields":{"brightness_shift":{"title":"明度"},"enable_lighting":{"description":"太陽光のON/OFFを切り替えることで、昼夜を表現することができます。","title":"太陽光"},"enable_sun":{"description":"宇宙空間に存在する太陽の表示を切り替えます。","title":"太陽"},"fog":{"description":"霧のON/OFFを切り替えます。","title":"霧"},"fog_density":{"description":"霧の濃度を0以上から設定します。","title":"濃度"},"ground_atmosphere":{"description":"地表の大気圏のON/OFFを切り替えます。","title":"地表の大気"},"hue_shift":{"title":"色相"},"sky_atmosphere":{"description":"地球を覆う大気圏のON/OFFを切り替えます。","title":"上空の大気"},"surturation_shift":{"title":"彩度"}},"title":"大気"},"default":{"fields":{"bgcolor":{"description":"宇宙空間が非表示の場合の、背景色を設定します。","title":"背景色"},"camera":{"description":"ページロード後最初に表示するカメラの位置を設定します。","title":"カメラ初期位置"},"ion":{"description":"自身のCesium IonアカウントからAPIキーを発行し、ここに設定します。Cesium Ionのアセット（タイルデータ、3Dデータなど）の使用が可能になるため、設定を推奨します。","title":"Cesium Icon APIアクセストークン"},"skybox":{"description":"宇宙空間の表示を切り替えます。","title":"宇宙の表示"},"terrain":{"description":"有効にすると、標高データが読み込みこまれ、立体的な地形を表現することができます。","title":"地形"}},"title":"シーン"},"googleAnalytics":{"description":"Google Analyticsを有効にすることで、公開ページがどのように閲覧されているかを分析することが可能です。","fields":{"enableGA":{"description":"Google Analyticsを有効にします。","title":"有効"},"trackingCode":{"description":"ここにグーグルアナリティクスのトラッキングIDを貼り付けることで、公開プロジェクトにこのコードが埋め込まれます。","title":"トラッキングID"}},"title":"Google Analytics"},"tiles":{"description":"手持ちのタイルデータを使用し、地球上に表示することができます。","fields":{"tile_maxLevel":{"title":"最大レベル"},"tile_minLevel":{"title":"最小レベル"},"tile_title":{"title":"名前"},"tile_type":{"choices":{"black_marble":"Black Marble","default":"デフォルト","default_label":"ラベル付き地図","default_road":"道路地図","esri_world_topo":"ESRI Topography","japan_gsi_standard":"地理院地図 標準地図","open_street_map":"Open Street Map","stamen_toner":"Stamen Toner","stamen_watercolor":"Stamen Watercolor","url":"URL"},"title":"種類"},"tile_url":{"title":"URL"}},"title":"タイル"}},"title":"Cesium"},"dlblock":{"description":"表ブロック","propertySchema":{"default":{"fields":{"title":{"title":"タイトル"},"typography":{"title":"フォント"}},"title":"表ブロック"},"items":{"fields":{"item_datanum":{"title":"データ(数字)"},"item_datastr":{"title":"データ(文字)"},"item_datatype":{"choices":{"number":"数字","string":"文字"},"title":"種類"},"item_title":{"title":"タイトル"}},"title":"アイテム"}},"title":"表"},"ellipsoid":{"description":"楕円形ツールを地図上にドラッグ\u0026ドロップすることで追加できます。楕円形ツールによって立体的なオブジェクトを地図上に表示できます。","propertySchema":{"default":{"fields":{"fillColor":{"title":"塗り色"},"height":{"title":"高度"},"position":{"title":"位置"},"radius":{"title":"半径"}},"title":"球体ツール"}},"title":"球体ツール"},"imageblock":{"description":"画像ブロック","propertySchema":{"default":{"fields":{"fullSize":{"title":"フルサイズ"},"image":{"title":"画像"},"imagePositionX":{"choices":{"center":"中央","left":"左","right":"右"},"title":"水平位置"},"imagePositionY":{"choices":{"bottom":"下","center":"中央","top":"上"},"title":"垂直位置"},"imageSize":{"choices":{"contain":"含む","cover":"カバー"},"title":"画像サイズ"},"title":{"title":"タイトル"}},"title":"画像ブロック"}},"title":"画像"},"infobox":{"description":"閲覧者が地図上のレイヤーをクリックした時に表示されるボックスです。テキストや画像、動画などのコンテンツを表示することができます。","propertySchema":{"default":{"fields":{"bgcolor":{"title":"背景色"},"size":{"choices":{"large":"大","small":"小"},"title":"サイズ"},"title":{"title":"タイトル"},"typography":{"title":"フォント"}},"title":"インフォボックス"}},"title":"インフォボックス"},"locationblock":{"description":"位置情報ブロック","propertySchema":{"default":{"fields":{"fullSize":{"title":"フルサイズ"},"location":{"title":"位置情報"},"title":{"title":"タイトル"}},"title":"位置情報ブロック"}},"title":"位置情報"},"marker":{"description":"ドラッグ\u0026ドロップすることで、地図上にマーカーを追加します。マーカーにはテキストや画像を紐づけることができ、閲覧者はマーカーをクリックすることでそれらのコンテンツを見ることができます。","propertySchema":{"default":{"fields":{"extrude":{"title":"地面から線を伸ばす"},"height":{"title":"高度"},"image":{"title":"画像URL"},"imageCrop":{"choices":{"circle":"円形","none":"なし"},"title":"切り抜き"},"imageShadow":{"title":"シャドウ"},"imageShadowBlur":{"title":"シャドウ半径"},"imageShadowColor":{"title":"シャドウ色"},"imageShadowPositionX":{"title":"シャドウX"},"imageShadowPositionY":{"title":"シャドウY"},"imageSize":{"title":"画像サイズ"},"label":{"title":"ラベル"},"labelText":{"title":"ラベル文字"},"labelTypography":{"title":"ラベルフォント"},"location":{"title":"位置"},"pointColor":{"title":"ポイント色"},"pointSize":{"title":"ポイントサイズ"},"style":{"choices":{"image":"アイコン","point":"ポイント"},"title":"表示方法"}},"title":"マーカー"}},"title":"マーカー"},"menu":{"description":"シーンにボタンを設置し、メニューを表示します。追加したボタンに設定されたアクションタイプによって動作が変わります。\\n・リンク：ボタン自体が外部サイトへのリンクになります。\\n・メニュー：追加したメニューを開きます\\n・カメラアクション：クリック時にカメラを移動します。","propertySchema":{"buttons":{"fields":{"buttonBgcolor":{"title":"背景色"},"buttonCamera":{"title":"カメラ"},"buttonColor":{"title":"テキスト色"},"buttonIcon":{"title":"アイコン"},"buttonInvisible":{"title":"非表示"},"buttonLink":{"title":"リンク"},"buttonPosition":{"choices":{"bottomleft":"下左","bottomright":"下右","topleft":"上左","topright":"上右"},"title":"表示位置"},"buttonStyle":{"choices":{"icon":"アイコンのみ","text":"テキストのみ","texticon":"テキスト＋アイコン"},"title":"表示方法"},"buttonTitle":{"title":"タイトル"},"buttonType":{"choices":{"camera":"カメラ移動","link":"リンク","menu":"メニュー開閉"},"title":"アクション"}},"title":"ボタン"},"menu":{"fields":{"menuCamera":{"title":"カメラ"},"menuIcon":{"title":"アイコン"},"menuLink":{"title":"リンク"},"menuTitle":{"title":"タイトル"},"menuType":{"choices":{"border":"区切り線","camera":"カメラ移動","link":"リンク"},"title":"アクション"}},"title":"メニュー"}},"title":"メニュー"},"photooverlay":{"description":"地図上に追加されたフォトオーバーレイを選択すると、設定した画像をモーダル形式で表示することができます。","propertySchema":{"default":{"fields":{"camera":{"description":"クリックされたときに移動するカメラの設定をします。","title":"カメラ"},"height":{"title":"高度"},"image":{"title":"アイコン"},"imageCrop":{"choices":{"circle":"円形","none":"なし"},"title":"切り抜き"},"imageShadow":{"title":"アイコンシャドウ"},"imageShadowBlur":{"title":"シャドウ半径"},"imageShadowColor":{"title":"シャドウ色"},"imageShadowPositionX":{"title":"シャドウX"},"imageShadowPositionY":{"title":"シャドウY"},"imageSize":{"title":"アイコンサイズ"},"location":{"title":"位置"},"photoOverlayImage":{"title":"オーバレイ画像"}},"title":"フォトオーバーレイ"}},"title":"フォトオーバーレイ"},"polygon":{"description":"Polygon primitive","propertySchema":{"default":{"fields":{"fill":{"title":"塗り"},"fillColor":{"title":"塗り色"},"polygon":{"title":"ポリゴン"},"stroke":{"title":"線"},"strokeColor":{"title":"線色"},"strokeWidth":{"title":"線幅"}},"title":"ポリゴン"}},"title":"ポリゴン"},"polyline":{"description":"Polyline primitive","propertySchema":{"default":{"fields":{"coordinates":{"title":"頂点"},"strokeColor":{"title":"線色"},"strokeWidth":{"title":"線幅"}},"title":"直線"}},"title":"直線"},"rect":{"description":"Rectangle primitive","propertySchema":{"default":{"fields":{"extrudedHeight":{"title":"高さ"},"fillColor":{"title":"塗り色"},"height":{"title":"高度"},"image":{"title":"画像URL"},"rect":{"title":"長方形"},"style":{"choices":{"color":"色","image":"画像"},"title":"スタイル"}},"title":"長方形"}},"title":"長方形"},"resource":{"description":"外部からデータ（形式何？？？）をインポートすることができます。地図上に追加後、URLを指定することで外部データが読み込まれます。","propertySchema":{"default":{"fields":{"url":{"choices":{"auto":"自動","czml":"CZML","geojson":"GeoJSON / TopoJSON","kml":"KML"},"title":"ファイル URL"}},"title":"ファイル"}},"title":"ファイル"},"splashscreen":{"description":"ページロード後、最初に表示される演出を設定できます。例えば、プロジェクトのタイトルを閲覧者に見せたり、カメラを移動させることができます。","propertySchema":{"camera":{"fields":{"cameraDelay":{"title":"カメラ移動時間"},"cameraDuration":{"title":"カメラ開始時間"},"cameraPosition":{"title":"カメラ位置"}},"title":"カメラアニメーション"},"overlay":{"fields":{"overlayBgcolor":{"title":"背景色"},"overlayDelay":{"title":"開始時間"},"overlayDuration":{"title":"表示時間"},"overlayEnabled":{"title":"有効"},"overlayImage":{"title":"オーバーレイ画像"},"overlayImageH":{"title":"画像高さ"},"overlayImageW":{"title":"画像幅"},"overlayTransitionDuration":{"title":"フェード時間"}},"title":"オーバーレイ"}},"title":"スプラッシュスクリーン"},"storytelling":{"description":"ストーリーテリング機能を使えば、データ間の繋がりや時系列をもとに、順番に資料を閲覧してもらうことが可能です。使用するには、右パネルから地球上のレイヤーに順番を付与します。","propertySchema":{"default":{"fields":{"autoStart":{"title":"自動再生"},"camera":{"title":"カメラ"},"duration":{"title":"カメラ移動時間"},"range":{"title":"画角"}},"title":"デフォルト"},"stories":{"fields":{"layer":{"title":"レイヤー"},"layerCamera":{"title":"カメラ"},"layerDuration":{"title":"移動時間"},"layerRange":{"title":"カメラ画角"}},"title":"ストーリー"}},"title":"ストーリーテリング"},"textblock":{"description":"Text block","propertySchema":{"default":{"fields":{"markdown":{"title":"マークダウン"},"text":{"title":"コンテンツ"},"title":{"title":"タイトル"},"typography":{"title":"フォント"}},"title":"テキストブロック"}},"title":"テキスト"},"videoblock":{"description":"動画ブロック","propertySchema":{"default":{"fields":{"fullSize":{"title":"フルサイズ"},"title":{"title":"タイトル"},"url":{"title":"動画 URL"}},"title":"動画ブロック"}},"title":"動画"}},"title":"Re:Earth公式プラグイン"}`
diff --git a/pkg/id/asset_gen_test.go b/pkg/id/asset_gen_test.go
new file mode 100644
index 00000000..99392f3a
--- /dev/null
+++ b/pkg/id/asset_gen_test.go
@@ -0,0 +1,1004 @@
+// Code generated by gen, DO NOT EDIT.
+
+package id
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/oklog/ulid"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewAssetID(t *testing.T) {
+	id := NewAssetID()
+	assert.NotNil(t, id)
+	ulID, err := ulid.Parse(id.String())
+
+	assert.NotNil(t, ulID)
+	assert.Nil(t, err)
+}
+
+func TestAssetIDFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			result AssetID
+			err    error
+		}
+	}{
+		{
+			name:  "Fail:Not valid string",
+			input: "testMustFail",
+			expected: struct {
+				result AssetID
+				err    error
+			}{
+				AssetID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "Fail:Not valid string",
+			input: "",
+			expected: struct {
+				result AssetID
+				err    error
+			}{
+				AssetID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "success:valid string",
+			input: "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: struct {
+				result AssetID
+				err    error
+			}{
+				AssetID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+				nil,
+			},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result, err := AssetIDFrom(tc.input)
+			assert.Equal(tt, tc.expected.result, result)
+			if err != nil {
+				assert.True(tt, errors.As(tc.expected.err, &err))
+			}
+		})
+	}
+}
+
+func TestMustAssetID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name        string
+		input       string
+		shouldPanic bool
+		expected    AssetID
+	}{
+		{
+			name:        "Fail:Not valid string",
+			input:       "testMustFail",
+			shouldPanic: true,
+		},
+		{
+			name:        "Fail:Not valid string",
+			input:       "",
+			shouldPanic: true,
+		},
+		{
+			name:        "success:valid string",
+			input:       "01f2r7kg1fvvffp0gmexgy5hxy",
+			shouldPanic: false,
+			expected:    AssetID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.shouldPanic {
+				assert.Panics(tt, func() { MustBeID(tc.input) })
+				return
+			}
+			result := MustAssetID(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
+
+func TestAssetIDFromRef(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected *AssetID
+	}{
+		{
+			name:     "Fail:Not valid string",
+			input:    "testMustFail",
+			expected: nil,
+		},
+		{
+			name:     "Fail:Not valid string",
+			input:    "",
+			expected: nil,
+		},
+		{
+			name:     "success:valid string",
+			input:    "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: &AssetID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := AssetIDFromRef(&tc.input)
+			assert.Equal(tt, tc.expected, result)
+			if tc.expected != nil {
+				assert.Equal(tt, *tc.expected, *result)
+			}
+		})
+	}
+}
+
+func TestAssetIDFromRefID(t *testing.T) {
+	id := New()
+
+	subId := AssetIDFromRefID(&id)
+
+	assert.NotNil(t, subId)
+	assert.Equal(t, subId.id, id.id)
+}
+
+func TestAssetID_ID(t *testing.T) {
+	id := New()
+	subId := AssetIDFromRefID(&id)
+
+	idOrg := subId.ID()
+
+	assert.Equal(t, id, idOrg)
+}
+
+func TestAssetID_String(t *testing.T) {
+	id := New()
+	subId := AssetIDFromRefID(&id)
+
+	assert.Equal(t, subId.String(), id.String())
+}
+
+func TestAssetID_GoString(t *testing.T) {
+	id := New()
+	subId := AssetIDFromRefID(&id)
+
+	assert.Equal(t, subId.GoString(), "id.AssetID("+id.String()+")")
+}
+
+func TestAssetID_RefString(t *testing.T) {
+	id := New()
+	subId := AssetIDFromRefID(&id)
+
+	refString := subId.StringRef()
+
+	assert.NotNil(t, refString)
+	assert.Equal(t, *refString, id.String())
+}
+
+func TestAssetID_Ref(t *testing.T) {
+	id := New()
+	subId := AssetIDFromRefID(&id)
+
+	subIdRef := subId.Ref()
+
+	assert.Equal(t, *subId, *subIdRef)
+}
+
+func TestAssetID_CopyRef(t *testing.T) {
+	id := New()
+	subId := AssetIDFromRefID(&id)
+
+	subIdCopyRef := subId.CopyRef()
+
+	assert.Equal(t, *subId, *subIdCopyRef)
+	assert.NotSame(t, subId, subIdCopyRef)
+}
+
+func TestAssetID_IDRef(t *testing.T) {
+	id := New()
+	subId := AssetIDFromRefID(&id)
+
+	assert.Equal(t, id, *subId.IDRef())
+}
+
+func TestAssetID_StringRef(t *testing.T) {
+	id := New()
+	subId := AssetIDFromRefID(&id)
+
+	assert.Equal(t, *subId.StringRef(), id.String())
+}
+
+func TestAssetID_MarhsalJSON(t *testing.T) {
+	id := New()
+	subId := AssetIDFromRefID(&id)
+
+	res, err := subId.MarhsalJSON()
+	exp, _ := json.Marshal(subId.String())
+
+	assert.Nil(t, err)
+	assert.Equal(t, exp, res)
+}
+
+func TestAssetID_UnmarhsalJSON(t *testing.T) {
+	jsonString := "\"01f3zhkysvcxsnzepyyqtq21fb\""
+
+	subId := &AssetID{}
+
+	err := subId.UnmarhsalJSON([]byte(jsonString))
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhkysvcxsnzepyyqtq21fb", subId.String())
+}
+
+func TestAssetID_MarshalText(t *testing.T) {
+	id := New()
+	subId := AssetIDFromRefID(&id)
+
+	res, err := subId.MarshalText()
+
+	assert.Nil(t, err)
+	assert.Equal(t, []byte(id.String()), res)
+}
+
+func TestAssetID_UnmarshalText(t *testing.T) {
+	text := []byte("01f3zhcaq35403zdjnd6dcm0t2")
+
+	subId := &AssetID{}
+
+	err := subId.UnmarshalText(text)
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhcaq35403zdjnd6dcm0t2", subId.String())
+
+}
+
+func TestAssetID_IsNil(t *testing.T) {
+	subId := AssetID{}
+
+	assert.True(t, subId.IsNil())
+
+	id := New()
+	subId = *AssetIDFromRefID(&id)
+
+	assert.False(t, subId.IsNil())
+}
+
+func TestAssetIDToKeys(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []AssetID
+		expected []string
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]AssetID, 0),
+			expected: make([]string, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []AssetID{MustAssetID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+		},
+		{
+			name: "multiple elements",
+			input: []AssetID{
+				MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustAssetID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustAssetID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, AssetIDToKeys(tc.input))
+		})
+	}
+
+}
+
+func TestAssetIDsFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []string
+		expected struct {
+			res []AssetID
+			err error
+		}
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]string, 0),
+			expected: struct {
+				res []AssetID
+				err error
+			}{
+				res: make([]AssetID, 0),
+				err: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+			expected: struct {
+				res []AssetID
+				err error
+			}{
+				res: []AssetID{MustAssetID("01f3zhcaq35403zdjnd6dcm0t2")},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []AssetID
+				err error
+			}{
+				res: []AssetID{
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []AssetID
+				err error
+			}{
+				res: nil,
+				err: ErrInvalidID,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.expected.err != nil {
+				_, err := AssetIDsFrom(tc.input)
+				assert.True(tt, errors.As(ErrInvalidID, &err))
+			} else {
+				res, err := AssetIDsFrom(tc.input)
+				assert.Equal(tt, tc.expected.res, res)
+				assert.Nil(tt, err)
+			}
+
+		})
+	}
+}
+
+func TestAssetIDsFromID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []ID
+		expected []AssetID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]ID, 0),
+			expected: make([]AssetID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []AssetID{MustAssetID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []AssetID{
+				MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustAssetID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustAssetID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := AssetIDsFromID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestAssetIDsFromIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+
+	testCases := []struct {
+		name     string
+		input    []*ID
+		expected []AssetID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*ID, 0),
+			expected: make([]AssetID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*ID{&id1},
+			expected: []AssetID{MustAssetID(id1.String())},
+		},
+		{
+			name:  "multiple elements",
+			input: []*ID{&id1, &id2, &id3},
+			expected: []AssetID{
+				MustAssetID(id1.String()),
+				MustAssetID(id2.String()),
+				MustAssetID(id3.String()),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := AssetIDsFromIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestAssetIDsToID(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []AssetID
+		expected []ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]AssetID, 0),
+			expected: make([]ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []AssetID{MustAssetID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []AssetID{
+				MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustAssetID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustAssetID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := AssetIDsToID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestAssetIDsToIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	subId1 := MustAssetID(id1.String())
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	subId2 := MustAssetID(id2.String())
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+	subId3 := MustAssetID(id3.String())
+
+	testCases := []struct {
+		name     string
+		input    []*AssetID
+		expected []*ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*AssetID, 0),
+			expected: make([]*ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*AssetID{&subId1},
+			expected: []*ID{&id1},
+		},
+		{
+			name:     "multiple elements",
+			input:    []*AssetID{&subId1, &subId2, &subId3},
+			expected: []*ID{&id1, &id2, &id3},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := AssetIDsToIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestNewAssetIDSet(t *testing.T) {
+	AssetIdSet := NewAssetIDSet()
+
+	assert.NotNil(t, AssetIdSet)
+	assert.Empty(t, AssetIdSet.m)
+	assert.Empty(t, AssetIdSet.s)
+}
+
+func TestAssetIDSet_Add(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []AssetID
+		expected *AssetIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]AssetID, 0),
+			expected: &AssetIDSet{
+				m: map[AssetID]struct{}{},
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []AssetID{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: &AssetIDSet{
+				m: map[AssetID]struct{}{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []AssetID{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []AssetID{
+				MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustAssetID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustAssetID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &AssetIDSet{
+				m: map[AssetID]struct{}{
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []AssetID{
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+		{
+			name: "multiple elements with duplication",
+			input: []AssetID{
+				MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustAssetID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &AssetIDSet{
+				m: map[AssetID]struct{}{
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []AssetID{
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewAssetIDSet()
+			set.Add(tc.input...)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestAssetIDSet_AddRef(t *testing.T) {
+	t.Parallel()
+
+	AssetId := MustAssetID("01f3zhcaq35403zdjnd6dcm0t1")
+
+	testCases := []struct {
+		name     string
+		input    *AssetID
+		expected *AssetIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: nil,
+			expected: &AssetIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: &AssetId,
+			expected: &AssetIDSet{
+				m: map[AssetID]struct{}{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []AssetID{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewAssetIDSet()
+			set.AddRef(tc.input)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestAssetIDSet_Has(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			AssetIDSet
+			AssetID
+		}
+		expected bool
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				AssetIDSet
+				AssetID
+			}{AssetIDSet: AssetIDSet{}, AssetID: MustAssetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: false,
+		},
+		{
+			name: "Set Contains the element",
+			input: struct {
+				AssetIDSet
+				AssetID
+			}{AssetIDSet: AssetIDSet{
+				m: map[AssetID]struct{}{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []AssetID{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, AssetID: MustAssetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: true,
+		},
+		{
+			name: "Set does not Contains the element",
+			input: struct {
+				AssetIDSet
+				AssetID
+			}{AssetIDSet: AssetIDSet{
+				m: map[AssetID]struct{}{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []AssetID{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, AssetID: MustAssetID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, tc.input.AssetIDSet.Has(tc.input.AssetID))
+		})
+	}
+}
+
+func TestAssetIDSet_Clear(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    AssetIDSet
+		expected AssetIDSet
+	}{
+		{
+			name:  "Empty Set",
+			input: AssetIDSet{},
+			expected: AssetIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name: "Set Contains the element",
+			input: AssetIDSet{
+				m: map[AssetID]struct{}{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []AssetID{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: AssetIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			set := tc.input
+			p := &set
+			p.Clear()
+			assert.Equal(tt, tc.expected, *p)
+		})
+	}
+}
+
+func TestAssetIDSet_All(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *AssetIDSet
+		expected []AssetID
+	}{
+		{
+			name: "Empty slice",
+			input: &AssetIDSet{
+				m: map[AssetID]struct{}{},
+				s: nil,
+			},
+			expected: make([]AssetID, 0),
+		},
+		{
+			name: "1 element",
+			input: &AssetIDSet{
+				m: map[AssetID]struct{}{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []AssetID{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: []AssetID{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1")},
+		},
+		{
+			name: "multiple elements",
+			input: &AssetIDSet{
+				m: map[AssetID]struct{}{
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []AssetID{
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: []AssetID{
+				MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustAssetID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustAssetID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.All())
+		})
+	}
+}
+
+func TestAssetIDSet_Clone(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *AssetIDSet
+		expected *AssetIDSet
+	}{
+		{
+			name:     "nil set",
+			input:    nil,
+			expected: NewAssetIDSet(),
+		},
+		{
+			name:     "Empty set",
+			input:    NewAssetIDSet(),
+			expected: NewAssetIDSet(),
+		},
+		{
+			name: "1 element",
+			input: &AssetIDSet{
+				m: map[AssetID]struct{}{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []AssetID{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: &AssetIDSet{
+				m: map[AssetID]struct{}{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []AssetID{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: &AssetIDSet{
+				m: map[AssetID]struct{}{
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []AssetID{
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: &AssetIDSet{
+				m: map[AssetID]struct{}{
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []AssetID{
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			clone := tc.input.Clone()
+			assert.Equal(tt, tc.expected, clone)
+			assert.False(tt, tc.input == clone)
+		})
+	}
+}
+
+func TestAssetIDSet_Merge(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			a *AssetIDSet
+			b *AssetIDSet
+		}
+		expected *AssetIDSet
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				a *AssetIDSet
+				b *AssetIDSet
+			}{
+				a: &AssetIDSet{},
+				b: &AssetIDSet{},
+			},
+			expected: &AssetIDSet{},
+		},
+		{
+			name: "1 Empty Set",
+			input: struct {
+				a *AssetIDSet
+				b *AssetIDSet
+			}{
+				a: &AssetIDSet{
+					m: map[AssetID]struct{}{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []AssetID{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &AssetIDSet{},
+			},
+			expected: &AssetIDSet{
+				m: map[AssetID]struct{}{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []AssetID{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "2 non Empty Set",
+			input: struct {
+				a *AssetIDSet
+				b *AssetIDSet
+			}{
+				a: &AssetIDSet{
+					m: map[AssetID]struct{}{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []AssetID{MustAssetID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &AssetIDSet{
+					m: map[AssetID]struct{}{MustAssetID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{}},
+					s: []AssetID{MustAssetID("01f3zhcaq35403zdjnd6dcm0t2")},
+				},
+			},
+			expected: &AssetIDSet{
+				m: map[AssetID]struct{}{
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+				},
+				s: []AssetID{
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustAssetID("01f3zhcaq35403zdjnd6dcm0t2"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.a.Merge(tc.input.b))
+		})
+	}
+}
diff --git a/pkg/id/dataset_gen_test.go b/pkg/id/dataset_gen_test.go
new file mode 100644
index 00000000..e5a29f7f
--- /dev/null
+++ b/pkg/id/dataset_gen_test.go
@@ -0,0 +1,1004 @@
+// Code generated by gen, DO NOT EDIT.
+
+package id
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/oklog/ulid"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewDatasetID(t *testing.T) {
+	id := NewDatasetID()
+	assert.NotNil(t, id)
+	ulID, err := ulid.Parse(id.String())
+
+	assert.NotNil(t, ulID)
+	assert.Nil(t, err)
+}
+
+func TestDatasetIDFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			result DatasetID
+			err    error
+		}
+	}{
+		{
+			name:  "Fail:Not valid string",
+			input: "testMustFail",
+			expected: struct {
+				result DatasetID
+				err    error
+			}{
+				DatasetID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "Fail:Not valid string",
+			input: "",
+			expected: struct {
+				result DatasetID
+				err    error
+			}{
+				DatasetID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "success:valid string",
+			input: "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: struct {
+				result DatasetID
+				err    error
+			}{
+				DatasetID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+				nil,
+			},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result, err := DatasetIDFrom(tc.input)
+			assert.Equal(tt, tc.expected.result, result)
+			if err != nil {
+				assert.True(tt, errors.As(tc.expected.err, &err))
+			}
+		})
+	}
+}
+
+func TestMustDatasetID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name        string
+		input       string
+		shouldPanic bool
+		expected    DatasetID
+	}{
+		{
+			name:        "Fail:Not valid string",
+			input:       "testMustFail",
+			shouldPanic: true,
+		},
+		{
+			name:        "Fail:Not valid string",
+			input:       "",
+			shouldPanic: true,
+		},
+		{
+			name:        "success:valid string",
+			input:       "01f2r7kg1fvvffp0gmexgy5hxy",
+			shouldPanic: false,
+			expected:    DatasetID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.shouldPanic {
+				assert.Panics(tt, func() { MustBeID(tc.input) })
+				return
+			}
+			result := MustDatasetID(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
+
+func TestDatasetIDFromRef(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected *DatasetID
+	}{
+		{
+			name:     "Fail:Not valid string",
+			input:    "testMustFail",
+			expected: nil,
+		},
+		{
+			name:     "Fail:Not valid string",
+			input:    "",
+			expected: nil,
+		},
+		{
+			name:     "success:valid string",
+			input:    "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: &DatasetID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := DatasetIDFromRef(&tc.input)
+			assert.Equal(tt, tc.expected, result)
+			if tc.expected != nil {
+				assert.Equal(tt, *tc.expected, *result)
+			}
+		})
+	}
+}
+
+func TestDatasetIDFromRefID(t *testing.T) {
+	id := New()
+
+	subId := DatasetIDFromRefID(&id)
+
+	assert.NotNil(t, subId)
+	assert.Equal(t, subId.id, id.id)
+}
+
+func TestDatasetID_ID(t *testing.T) {
+	id := New()
+	subId := DatasetIDFromRefID(&id)
+
+	idOrg := subId.ID()
+
+	assert.Equal(t, id, idOrg)
+}
+
+func TestDatasetID_String(t *testing.T) {
+	id := New()
+	subId := DatasetIDFromRefID(&id)
+
+	assert.Equal(t, subId.String(), id.String())
+}
+
+func TestDatasetID_GoString(t *testing.T) {
+	id := New()
+	subId := DatasetIDFromRefID(&id)
+
+	assert.Equal(t, subId.GoString(), "id.DatasetID("+id.String()+")")
+}
+
+func TestDatasetID_RefString(t *testing.T) {
+	id := New()
+	subId := DatasetIDFromRefID(&id)
+
+	refString := subId.StringRef()
+
+	assert.NotNil(t, refString)
+	assert.Equal(t, *refString, id.String())
+}
+
+func TestDatasetID_Ref(t *testing.T) {
+	id := New()
+	subId := DatasetIDFromRefID(&id)
+
+	subIdRef := subId.Ref()
+
+	assert.Equal(t, *subId, *subIdRef)
+}
+
+func TestDatasetID_CopyRef(t *testing.T) {
+	id := New()
+	subId := DatasetIDFromRefID(&id)
+
+	subIdCopyRef := subId.CopyRef()
+
+	assert.Equal(t, *subId, *subIdCopyRef)
+	assert.NotSame(t, subId, subIdCopyRef)
+}
+
+func TestDatasetID_IDRef(t *testing.T) {
+	id := New()
+	subId := DatasetIDFromRefID(&id)
+
+	assert.Equal(t, id, *subId.IDRef())
+}
+
+func TestDatasetID_StringRef(t *testing.T) {
+	id := New()
+	subId := DatasetIDFromRefID(&id)
+
+	assert.Equal(t, *subId.StringRef(), id.String())
+}
+
+func TestDatasetID_MarhsalJSON(t *testing.T) {
+	id := New()
+	subId := DatasetIDFromRefID(&id)
+
+	res, err := subId.MarhsalJSON()
+	exp, _ := json.Marshal(subId.String())
+
+	assert.Nil(t, err)
+	assert.Equal(t, exp, res)
+}
+
+func TestDatasetID_UnmarhsalJSON(t *testing.T) {
+	jsonString := "\"01f3zhkysvcxsnzepyyqtq21fb\""
+
+	subId := &DatasetID{}
+
+	err := subId.UnmarhsalJSON([]byte(jsonString))
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhkysvcxsnzepyyqtq21fb", subId.String())
+}
+
+func TestDatasetID_MarshalText(t *testing.T) {
+	id := New()
+	subId := DatasetIDFromRefID(&id)
+
+	res, err := subId.MarshalText()
+
+	assert.Nil(t, err)
+	assert.Equal(t, []byte(id.String()), res)
+}
+
+func TestDatasetID_UnmarshalText(t *testing.T) {
+	text := []byte("01f3zhcaq35403zdjnd6dcm0t2")
+
+	subId := &DatasetID{}
+
+	err := subId.UnmarshalText(text)
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhcaq35403zdjnd6dcm0t2", subId.String())
+
+}
+
+func TestDatasetID_IsNil(t *testing.T) {
+	subId := DatasetID{}
+
+	assert.True(t, subId.IsNil())
+
+	id := New()
+	subId = *DatasetIDFromRefID(&id)
+
+	assert.False(t, subId.IsNil())
+}
+
+func TestDatasetIDToKeys(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []DatasetID
+		expected []string
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]DatasetID, 0),
+			expected: make([]string, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []DatasetID{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+		},
+		{
+			name: "multiple elements",
+			input: []DatasetID{
+				MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustDatasetID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, DatasetIDToKeys(tc.input))
+		})
+	}
+
+}
+
+func TestDatasetIDsFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []string
+		expected struct {
+			res []DatasetID
+			err error
+		}
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]string, 0),
+			expected: struct {
+				res []DatasetID
+				err error
+			}{
+				res: make([]DatasetID, 0),
+				err: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+			expected: struct {
+				res []DatasetID
+				err error
+			}{
+				res: []DatasetID{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2")},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []DatasetID
+				err error
+			}{
+				res: []DatasetID{
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []DatasetID
+				err error
+			}{
+				res: nil,
+				err: ErrInvalidID,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.expected.err != nil {
+				_, err := DatasetIDsFrom(tc.input)
+				assert.True(tt, errors.As(ErrInvalidID, &err))
+			} else {
+				res, err := DatasetIDsFrom(tc.input)
+				assert.Equal(tt, tc.expected.res, res)
+				assert.Nil(tt, err)
+			}
+
+		})
+	}
+}
+
+func TestDatasetIDsFromID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []ID
+		expected []DatasetID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]ID, 0),
+			expected: make([]DatasetID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []DatasetID{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []DatasetID{
+				MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustDatasetID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := DatasetIDsFromID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestDatasetIDsFromIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+
+	testCases := []struct {
+		name     string
+		input    []*ID
+		expected []DatasetID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*ID, 0),
+			expected: make([]DatasetID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*ID{&id1},
+			expected: []DatasetID{MustDatasetID(id1.String())},
+		},
+		{
+			name:  "multiple elements",
+			input: []*ID{&id1, &id2, &id3},
+			expected: []DatasetID{
+				MustDatasetID(id1.String()),
+				MustDatasetID(id2.String()),
+				MustDatasetID(id3.String()),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := DatasetIDsFromIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestDatasetIDsToID(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []DatasetID
+		expected []ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]DatasetID, 0),
+			expected: make([]ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []DatasetID{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []DatasetID{
+				MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustDatasetID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := DatasetIDsToID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestDatasetIDsToIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	subId1 := MustDatasetID(id1.String())
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	subId2 := MustDatasetID(id2.String())
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+	subId3 := MustDatasetID(id3.String())
+
+	testCases := []struct {
+		name     string
+		input    []*DatasetID
+		expected []*ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*DatasetID, 0),
+			expected: make([]*ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*DatasetID{&subId1},
+			expected: []*ID{&id1},
+		},
+		{
+			name:     "multiple elements",
+			input:    []*DatasetID{&subId1, &subId2, &subId3},
+			expected: []*ID{&id1, &id2, &id3},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := DatasetIDsToIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestNewDatasetIDSet(t *testing.T) {
+	DatasetIdSet := NewDatasetIDSet()
+
+	assert.NotNil(t, DatasetIdSet)
+	assert.Empty(t, DatasetIdSet.m)
+	assert.Empty(t, DatasetIdSet.s)
+}
+
+func TestDatasetIDSet_Add(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []DatasetID
+		expected *DatasetIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]DatasetID, 0),
+			expected: &DatasetIDSet{
+				m: map[DatasetID]struct{}{},
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []DatasetID{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: &DatasetIDSet{
+				m: map[DatasetID]struct{}{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetID{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []DatasetID{
+				MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustDatasetID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &DatasetIDSet{
+				m: map[DatasetID]struct{}{
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []DatasetID{
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+		{
+			name: "multiple elements with duplication",
+			input: []DatasetID{
+				MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &DatasetIDSet{
+				m: map[DatasetID]struct{}{
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []DatasetID{
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewDatasetIDSet()
+			set.Add(tc.input...)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestDatasetIDSet_AddRef(t *testing.T) {
+	t.Parallel()
+
+	DatasetId := MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1")
+
+	testCases := []struct {
+		name     string
+		input    *DatasetID
+		expected *DatasetIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: nil,
+			expected: &DatasetIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: &DatasetId,
+			expected: &DatasetIDSet{
+				m: map[DatasetID]struct{}{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetID{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewDatasetIDSet()
+			set.AddRef(tc.input)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestDatasetIDSet_Has(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			DatasetIDSet
+			DatasetID
+		}
+		expected bool
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				DatasetIDSet
+				DatasetID
+			}{DatasetIDSet: DatasetIDSet{}, DatasetID: MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: false,
+		},
+		{
+			name: "Set Contains the element",
+			input: struct {
+				DatasetIDSet
+				DatasetID
+			}{DatasetIDSet: DatasetIDSet{
+				m: map[DatasetID]struct{}{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetID{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, DatasetID: MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: true,
+		},
+		{
+			name: "Set does not Contains the element",
+			input: struct {
+				DatasetIDSet
+				DatasetID
+			}{DatasetIDSet: DatasetIDSet{
+				m: map[DatasetID]struct{}{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetID{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, DatasetID: MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, tc.input.DatasetIDSet.Has(tc.input.DatasetID))
+		})
+	}
+}
+
+func TestDatasetIDSet_Clear(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    DatasetIDSet
+		expected DatasetIDSet
+	}{
+		{
+			name:  "Empty Set",
+			input: DatasetIDSet{},
+			expected: DatasetIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name: "Set Contains the element",
+			input: DatasetIDSet{
+				m: map[DatasetID]struct{}{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetID{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: DatasetIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			set := tc.input
+			p := &set
+			p.Clear()
+			assert.Equal(tt, tc.expected, *p)
+		})
+	}
+}
+
+func TestDatasetIDSet_All(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *DatasetIDSet
+		expected []DatasetID
+	}{
+		{
+			name: "Empty slice",
+			input: &DatasetIDSet{
+				m: map[DatasetID]struct{}{},
+				s: nil,
+			},
+			expected: make([]DatasetID, 0),
+		},
+		{
+			name: "1 element",
+			input: &DatasetIDSet{
+				m: map[DatasetID]struct{}{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetID{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: []DatasetID{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1")},
+		},
+		{
+			name: "multiple elements",
+			input: &DatasetIDSet{
+				m: map[DatasetID]struct{}{
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []DatasetID{
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: []DatasetID{
+				MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustDatasetID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.All())
+		})
+	}
+}
+
+func TestDatasetIDSet_Clone(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *DatasetIDSet
+		expected *DatasetIDSet
+	}{
+		{
+			name:     "nil set",
+			input:    nil,
+			expected: NewDatasetIDSet(),
+		},
+		{
+			name:     "Empty set",
+			input:    NewDatasetIDSet(),
+			expected: NewDatasetIDSet(),
+		},
+		{
+			name: "1 element",
+			input: &DatasetIDSet{
+				m: map[DatasetID]struct{}{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetID{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: &DatasetIDSet{
+				m: map[DatasetID]struct{}{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetID{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: &DatasetIDSet{
+				m: map[DatasetID]struct{}{
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []DatasetID{
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: &DatasetIDSet{
+				m: map[DatasetID]struct{}{
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []DatasetID{
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			clone := tc.input.Clone()
+			assert.Equal(tt, tc.expected, clone)
+			assert.False(tt, tc.input == clone)
+		})
+	}
+}
+
+func TestDatasetIDSet_Merge(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			a *DatasetIDSet
+			b *DatasetIDSet
+		}
+		expected *DatasetIDSet
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				a *DatasetIDSet
+				b *DatasetIDSet
+			}{
+				a: &DatasetIDSet{},
+				b: &DatasetIDSet{},
+			},
+			expected: &DatasetIDSet{},
+		},
+		{
+			name: "1 Empty Set",
+			input: struct {
+				a *DatasetIDSet
+				b *DatasetIDSet
+			}{
+				a: &DatasetIDSet{
+					m: map[DatasetID]struct{}{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []DatasetID{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &DatasetIDSet{},
+			},
+			expected: &DatasetIDSet{
+				m: map[DatasetID]struct{}{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetID{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "2 non Empty Set",
+			input: struct {
+				a *DatasetIDSet
+				b *DatasetIDSet
+			}{
+				a: &DatasetIDSet{
+					m: map[DatasetID]struct{}{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []DatasetID{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &DatasetIDSet{
+					m: map[DatasetID]struct{}{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{}},
+					s: []DatasetID{MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2")},
+				},
+			},
+			expected: &DatasetIDSet{
+				m: map[DatasetID]struct{}{
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+				},
+				s: []DatasetID{
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetID("01f3zhcaq35403zdjnd6dcm0t2"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.a.Merge(tc.input.b))
+		})
+	}
+}
diff --git a/pkg/id/dataset_schema_field_gen.go b/pkg/id/dataset_schema_field_gen.go
index b11285ae..e73a28ca 100644
--- a/pkg/id/dataset_schema_field_gen.go
+++ b/pkg/id/dataset_schema_field_gen.go
@@ -1,7 +1,9 @@
-// Code generated by idgen, DO NOT EDIT.
+// Code generated by gen, DO NOT EDIT.
 
 package id
 
+import "encoding/json"
+
 // DatasetSchemaFieldID is an ID for DatasetSchemaField.
 type DatasetSchemaFieldID ID
 
@@ -59,6 +61,11 @@ func (d DatasetSchemaFieldID) String() string {
 	return ID(d).String()
 }
 
+// GoString implements fmt.GoStringer interface.
+func (d DatasetSchemaFieldID) GoString() string {
+	return "id.DatasetSchemaFieldID(" + d.String() + ")"
+}
+
 // RefString returns a reference of string representation.
 func (d DatasetSchemaFieldID) RefString() *string {
 	id := ID(d).String()
@@ -98,6 +105,35 @@ func (d *DatasetSchemaFieldID) StringRef() *string {
 	return &id
 }
 
+// MarhsalJSON implements json.Marhsaler interface
+func (d *DatasetSchemaFieldID) MarhsalJSON() ([]byte, error) {
+	return json.Marshal(d.String())
+}
+
+// UnmarhsalJSON implements json.Unmarshaler interface
+func (d *DatasetSchemaFieldID) UnmarhsalJSON(bs []byte) (err error) {
+	var idstr string
+	if err = json.Unmarshal(bs, &idstr); err != nil {
+		return
+	}
+	*d, err = DatasetSchemaFieldIDFrom(idstr)
+	return
+}
+
+// MarshalText implements encoding.TextMarshaler interface
+func (d *DatasetSchemaFieldID) MarshalText() ([]byte, error) {
+	if d == nil {
+		return nil, nil
+	}
+	return []byte(d.String()), nil
+}
+
+// UnmarshalText implements encoding.TextUnmarshaler interface
+func (d *DatasetSchemaFieldID) UnmarshalText(text []byte) (err error) {
+	*d, err = DatasetSchemaFieldIDFrom(string(text))
+	return
+}
+
 // Ref returns true if a ID is nil or zero-value
 func (d DatasetSchemaFieldID) IsNil() bool {
 	return ID(d).IsNil()
diff --git a/pkg/id/dataset_schema_field_gen_test.go b/pkg/id/dataset_schema_field_gen_test.go
new file mode 100644
index 00000000..b6846079
--- /dev/null
+++ b/pkg/id/dataset_schema_field_gen_test.go
@@ -0,0 +1,1004 @@
+// Code generated by gen, DO NOT EDIT.
+
+package id
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/oklog/ulid"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewDatasetSchemaFieldID(t *testing.T) {
+	id := NewDatasetSchemaFieldID()
+	assert.NotNil(t, id)
+	ulID, err := ulid.Parse(id.String())
+
+	assert.NotNil(t, ulID)
+	assert.Nil(t, err)
+}
+
+func TestDatasetSchemaFieldIDFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			result DatasetSchemaFieldID
+			err    error
+		}
+	}{
+		{
+			name:  "Fail:Not valid string",
+			input: "testMustFail",
+			expected: struct {
+				result DatasetSchemaFieldID
+				err    error
+			}{
+				DatasetSchemaFieldID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "Fail:Not valid string",
+			input: "",
+			expected: struct {
+				result DatasetSchemaFieldID
+				err    error
+			}{
+				DatasetSchemaFieldID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "success:valid string",
+			input: "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: struct {
+				result DatasetSchemaFieldID
+				err    error
+			}{
+				DatasetSchemaFieldID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+				nil,
+			},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result, err := DatasetSchemaFieldIDFrom(tc.input)
+			assert.Equal(tt, tc.expected.result, result)
+			if err != nil {
+				assert.True(tt, errors.As(tc.expected.err, &err))
+			}
+		})
+	}
+}
+
+func TestMustDatasetSchemaFieldID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name        string
+		input       string
+		shouldPanic bool
+		expected    DatasetSchemaFieldID
+	}{
+		{
+			name:        "Fail:Not valid string",
+			input:       "testMustFail",
+			shouldPanic: true,
+		},
+		{
+			name:        "Fail:Not valid string",
+			input:       "",
+			shouldPanic: true,
+		},
+		{
+			name:        "success:valid string",
+			input:       "01f2r7kg1fvvffp0gmexgy5hxy",
+			shouldPanic: false,
+			expected:    DatasetSchemaFieldID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.shouldPanic {
+				assert.Panics(tt, func() { MustBeID(tc.input) })
+				return
+			}
+			result := MustDatasetSchemaFieldID(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
+
+func TestDatasetSchemaFieldIDFromRef(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected *DatasetSchemaFieldID
+	}{
+		{
+			name:     "Fail:Not valid string",
+			input:    "testMustFail",
+			expected: nil,
+		},
+		{
+			name:     "Fail:Not valid string",
+			input:    "",
+			expected: nil,
+		},
+		{
+			name:     "success:valid string",
+			input:    "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: &DatasetSchemaFieldID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := DatasetSchemaFieldIDFromRef(&tc.input)
+			assert.Equal(tt, tc.expected, result)
+			if tc.expected != nil {
+				assert.Equal(tt, *tc.expected, *result)
+			}
+		})
+	}
+}
+
+func TestDatasetSchemaFieldIDFromRefID(t *testing.T) {
+	id := New()
+
+	subId := DatasetSchemaFieldIDFromRefID(&id)
+
+	assert.NotNil(t, subId)
+	assert.Equal(t, subId.id, id.id)
+}
+
+func TestDatasetSchemaFieldID_ID(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaFieldIDFromRefID(&id)
+
+	idOrg := subId.ID()
+
+	assert.Equal(t, id, idOrg)
+}
+
+func TestDatasetSchemaFieldID_String(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaFieldIDFromRefID(&id)
+
+	assert.Equal(t, subId.String(), id.String())
+}
+
+func TestDatasetSchemaFieldID_GoString(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaFieldIDFromRefID(&id)
+
+	assert.Equal(t, subId.GoString(), "id.DatasetSchemaFieldID("+id.String()+")")
+}
+
+func TestDatasetSchemaFieldID_RefString(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaFieldIDFromRefID(&id)
+
+	refString := subId.StringRef()
+
+	assert.NotNil(t, refString)
+	assert.Equal(t, *refString, id.String())
+}
+
+func TestDatasetSchemaFieldID_Ref(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaFieldIDFromRefID(&id)
+
+	subIdRef := subId.Ref()
+
+	assert.Equal(t, *subId, *subIdRef)
+}
+
+func TestDatasetSchemaFieldID_CopyRef(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaFieldIDFromRefID(&id)
+
+	subIdCopyRef := subId.CopyRef()
+
+	assert.Equal(t, *subId, *subIdCopyRef)
+	assert.NotSame(t, subId, subIdCopyRef)
+}
+
+func TestDatasetSchemaFieldID_IDRef(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaFieldIDFromRefID(&id)
+
+	assert.Equal(t, id, *subId.IDRef())
+}
+
+func TestDatasetSchemaFieldID_StringRef(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaFieldIDFromRefID(&id)
+
+	assert.Equal(t, *subId.StringRef(), id.String())
+}
+
+func TestDatasetSchemaFieldID_MarhsalJSON(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaFieldIDFromRefID(&id)
+
+	res, err := subId.MarhsalJSON()
+	exp, _ := json.Marshal(subId.String())
+
+	assert.Nil(t, err)
+	assert.Equal(t, exp, res)
+}
+
+func TestDatasetSchemaFieldID_UnmarhsalJSON(t *testing.T) {
+	jsonString := "\"01f3zhkysvcxsnzepyyqtq21fb\""
+
+	subId := &DatasetSchemaFieldID{}
+
+	err := subId.UnmarhsalJSON([]byte(jsonString))
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhkysvcxsnzepyyqtq21fb", subId.String())
+}
+
+func TestDatasetSchemaFieldID_MarshalText(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaFieldIDFromRefID(&id)
+
+	res, err := subId.MarshalText()
+
+	assert.Nil(t, err)
+	assert.Equal(t, []byte(id.String()), res)
+}
+
+func TestDatasetSchemaFieldID_UnmarshalText(t *testing.T) {
+	text := []byte("01f3zhcaq35403zdjnd6dcm0t2")
+
+	subId := &DatasetSchemaFieldID{}
+
+	err := subId.UnmarshalText(text)
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhcaq35403zdjnd6dcm0t2", subId.String())
+
+}
+
+func TestDatasetSchemaFieldID_IsNil(t *testing.T) {
+	subId := DatasetSchemaFieldID{}
+
+	assert.True(t, subId.IsNil())
+
+	id := New()
+	subId = *DatasetSchemaFieldIDFromRefID(&id)
+
+	assert.False(t, subId.IsNil())
+}
+
+func TestDatasetSchemaFieldIDToKeys(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []DatasetSchemaFieldID
+		expected []string
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]DatasetSchemaFieldID, 0),
+			expected: make([]string, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []DatasetSchemaFieldID{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+		},
+		{
+			name: "multiple elements",
+			input: []DatasetSchemaFieldID{
+				MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, DatasetSchemaFieldIDToKeys(tc.input))
+		})
+	}
+
+}
+
+func TestDatasetSchemaFieldIDsFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []string
+		expected struct {
+			res []DatasetSchemaFieldID
+			err error
+		}
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]string, 0),
+			expected: struct {
+				res []DatasetSchemaFieldID
+				err error
+			}{
+				res: make([]DatasetSchemaFieldID, 0),
+				err: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+			expected: struct {
+				res []DatasetSchemaFieldID
+				err error
+			}{
+				res: []DatasetSchemaFieldID{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2")},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []DatasetSchemaFieldID
+				err error
+			}{
+				res: []DatasetSchemaFieldID{
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []DatasetSchemaFieldID
+				err error
+			}{
+				res: nil,
+				err: ErrInvalidID,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.expected.err != nil {
+				_, err := DatasetSchemaFieldIDsFrom(tc.input)
+				assert.True(tt, errors.As(ErrInvalidID, &err))
+			} else {
+				res, err := DatasetSchemaFieldIDsFrom(tc.input)
+				assert.Equal(tt, tc.expected.res, res)
+				assert.Nil(tt, err)
+			}
+
+		})
+	}
+}
+
+func TestDatasetSchemaFieldIDsFromID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []ID
+		expected []DatasetSchemaFieldID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]ID, 0),
+			expected: make([]DatasetSchemaFieldID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []DatasetSchemaFieldID{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []DatasetSchemaFieldID{
+				MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := DatasetSchemaFieldIDsFromID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestDatasetSchemaFieldIDsFromIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+
+	testCases := []struct {
+		name     string
+		input    []*ID
+		expected []DatasetSchemaFieldID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*ID, 0),
+			expected: make([]DatasetSchemaFieldID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*ID{&id1},
+			expected: []DatasetSchemaFieldID{MustDatasetSchemaFieldID(id1.String())},
+		},
+		{
+			name:  "multiple elements",
+			input: []*ID{&id1, &id2, &id3},
+			expected: []DatasetSchemaFieldID{
+				MustDatasetSchemaFieldID(id1.String()),
+				MustDatasetSchemaFieldID(id2.String()),
+				MustDatasetSchemaFieldID(id3.String()),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := DatasetSchemaFieldIDsFromIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestDatasetSchemaFieldIDsToID(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []DatasetSchemaFieldID
+		expected []ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]DatasetSchemaFieldID, 0),
+			expected: make([]ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []DatasetSchemaFieldID{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []DatasetSchemaFieldID{
+				MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := DatasetSchemaFieldIDsToID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestDatasetSchemaFieldIDsToIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	subId1 := MustDatasetSchemaFieldID(id1.String())
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	subId2 := MustDatasetSchemaFieldID(id2.String())
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+	subId3 := MustDatasetSchemaFieldID(id3.String())
+
+	testCases := []struct {
+		name     string
+		input    []*DatasetSchemaFieldID
+		expected []*ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*DatasetSchemaFieldID, 0),
+			expected: make([]*ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*DatasetSchemaFieldID{&subId1},
+			expected: []*ID{&id1},
+		},
+		{
+			name:     "multiple elements",
+			input:    []*DatasetSchemaFieldID{&subId1, &subId2, &subId3},
+			expected: []*ID{&id1, &id2, &id3},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := DatasetSchemaFieldIDsToIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestNewDatasetSchemaFieldIDSet(t *testing.T) {
+	DatasetSchemaFieldIdSet := NewDatasetSchemaFieldIDSet()
+
+	assert.NotNil(t, DatasetSchemaFieldIdSet)
+	assert.Empty(t, DatasetSchemaFieldIdSet.m)
+	assert.Empty(t, DatasetSchemaFieldIdSet.s)
+}
+
+func TestDatasetSchemaFieldIDSet_Add(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []DatasetSchemaFieldID
+		expected *DatasetSchemaFieldIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]DatasetSchemaFieldID, 0),
+			expected: &DatasetSchemaFieldIDSet{
+				m: map[DatasetSchemaFieldID]struct{}{},
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []DatasetSchemaFieldID{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: &DatasetSchemaFieldIDSet{
+				m: map[DatasetSchemaFieldID]struct{}{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetSchemaFieldID{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []DatasetSchemaFieldID{
+				MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &DatasetSchemaFieldIDSet{
+				m: map[DatasetSchemaFieldID]struct{}{
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []DatasetSchemaFieldID{
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+		{
+			name: "multiple elements with duplication",
+			input: []DatasetSchemaFieldID{
+				MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &DatasetSchemaFieldIDSet{
+				m: map[DatasetSchemaFieldID]struct{}{
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []DatasetSchemaFieldID{
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewDatasetSchemaFieldIDSet()
+			set.Add(tc.input...)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestDatasetSchemaFieldIDSet_AddRef(t *testing.T) {
+	t.Parallel()
+
+	DatasetSchemaFieldId := MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1")
+
+	testCases := []struct {
+		name     string
+		input    *DatasetSchemaFieldID
+		expected *DatasetSchemaFieldIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: nil,
+			expected: &DatasetSchemaFieldIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: &DatasetSchemaFieldId,
+			expected: &DatasetSchemaFieldIDSet{
+				m: map[DatasetSchemaFieldID]struct{}{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetSchemaFieldID{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewDatasetSchemaFieldIDSet()
+			set.AddRef(tc.input)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestDatasetSchemaFieldIDSet_Has(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			DatasetSchemaFieldIDSet
+			DatasetSchemaFieldID
+		}
+		expected bool
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				DatasetSchemaFieldIDSet
+				DatasetSchemaFieldID
+			}{DatasetSchemaFieldIDSet: DatasetSchemaFieldIDSet{}, DatasetSchemaFieldID: MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: false,
+		},
+		{
+			name: "Set Contains the element",
+			input: struct {
+				DatasetSchemaFieldIDSet
+				DatasetSchemaFieldID
+			}{DatasetSchemaFieldIDSet: DatasetSchemaFieldIDSet{
+				m: map[DatasetSchemaFieldID]struct{}{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetSchemaFieldID{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, DatasetSchemaFieldID: MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: true,
+		},
+		{
+			name: "Set does not Contains the element",
+			input: struct {
+				DatasetSchemaFieldIDSet
+				DatasetSchemaFieldID
+			}{DatasetSchemaFieldIDSet: DatasetSchemaFieldIDSet{
+				m: map[DatasetSchemaFieldID]struct{}{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetSchemaFieldID{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, DatasetSchemaFieldID: MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, tc.input.DatasetSchemaFieldIDSet.Has(tc.input.DatasetSchemaFieldID))
+		})
+	}
+}
+
+func TestDatasetSchemaFieldIDSet_Clear(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    DatasetSchemaFieldIDSet
+		expected DatasetSchemaFieldIDSet
+	}{
+		{
+			name:  "Empty Set",
+			input: DatasetSchemaFieldIDSet{},
+			expected: DatasetSchemaFieldIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name: "Set Contains the element",
+			input: DatasetSchemaFieldIDSet{
+				m: map[DatasetSchemaFieldID]struct{}{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetSchemaFieldID{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: DatasetSchemaFieldIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			set := tc.input
+			p := &set
+			p.Clear()
+			assert.Equal(tt, tc.expected, *p)
+		})
+	}
+}
+
+func TestDatasetSchemaFieldIDSet_All(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *DatasetSchemaFieldIDSet
+		expected []DatasetSchemaFieldID
+	}{
+		{
+			name: "Empty slice",
+			input: &DatasetSchemaFieldIDSet{
+				m: map[DatasetSchemaFieldID]struct{}{},
+				s: nil,
+			},
+			expected: make([]DatasetSchemaFieldID, 0),
+		},
+		{
+			name: "1 element",
+			input: &DatasetSchemaFieldIDSet{
+				m: map[DatasetSchemaFieldID]struct{}{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetSchemaFieldID{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: []DatasetSchemaFieldID{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+		},
+		{
+			name: "multiple elements",
+			input: &DatasetSchemaFieldIDSet{
+				m: map[DatasetSchemaFieldID]struct{}{
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []DatasetSchemaFieldID{
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: []DatasetSchemaFieldID{
+				MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.All())
+		})
+	}
+}
+
+func TestDatasetSchemaFieldIDSet_Clone(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *DatasetSchemaFieldIDSet
+		expected *DatasetSchemaFieldIDSet
+	}{
+		{
+			name:     "nil set",
+			input:    nil,
+			expected: NewDatasetSchemaFieldIDSet(),
+		},
+		{
+			name:     "Empty set",
+			input:    NewDatasetSchemaFieldIDSet(),
+			expected: NewDatasetSchemaFieldIDSet(),
+		},
+		{
+			name: "1 element",
+			input: &DatasetSchemaFieldIDSet{
+				m: map[DatasetSchemaFieldID]struct{}{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetSchemaFieldID{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: &DatasetSchemaFieldIDSet{
+				m: map[DatasetSchemaFieldID]struct{}{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetSchemaFieldID{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: &DatasetSchemaFieldIDSet{
+				m: map[DatasetSchemaFieldID]struct{}{
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []DatasetSchemaFieldID{
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: &DatasetSchemaFieldIDSet{
+				m: map[DatasetSchemaFieldID]struct{}{
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []DatasetSchemaFieldID{
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			clone := tc.input.Clone()
+			assert.Equal(tt, tc.expected, clone)
+			assert.False(tt, tc.input == clone)
+		})
+	}
+}
+
+func TestDatasetSchemaFieldIDSet_Merge(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			a *DatasetSchemaFieldIDSet
+			b *DatasetSchemaFieldIDSet
+		}
+		expected *DatasetSchemaFieldIDSet
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				a *DatasetSchemaFieldIDSet
+				b *DatasetSchemaFieldIDSet
+			}{
+				a: &DatasetSchemaFieldIDSet{},
+				b: &DatasetSchemaFieldIDSet{},
+			},
+			expected: &DatasetSchemaFieldIDSet{},
+		},
+		{
+			name: "1 Empty Set",
+			input: struct {
+				a *DatasetSchemaFieldIDSet
+				b *DatasetSchemaFieldIDSet
+			}{
+				a: &DatasetSchemaFieldIDSet{
+					m: map[DatasetSchemaFieldID]struct{}{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []DatasetSchemaFieldID{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &DatasetSchemaFieldIDSet{},
+			},
+			expected: &DatasetSchemaFieldIDSet{
+				m: map[DatasetSchemaFieldID]struct{}{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetSchemaFieldID{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "2 non Empty Set",
+			input: struct {
+				a *DatasetSchemaFieldIDSet
+				b *DatasetSchemaFieldIDSet
+			}{
+				a: &DatasetSchemaFieldIDSet{
+					m: map[DatasetSchemaFieldID]struct{}{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []DatasetSchemaFieldID{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &DatasetSchemaFieldIDSet{
+					m: map[DatasetSchemaFieldID]struct{}{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{}},
+					s: []DatasetSchemaFieldID{MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2")},
+				},
+			},
+			expected: &DatasetSchemaFieldIDSet{
+				m: map[DatasetSchemaFieldID]struct{}{
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+				},
+				s: []DatasetSchemaFieldID{
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetSchemaFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.a.Merge(tc.input.b))
+		})
+	}
+}
diff --git a/pkg/id/dataset_schema_gen_test.go b/pkg/id/dataset_schema_gen_test.go
new file mode 100644
index 00000000..9320f2b1
--- /dev/null
+++ b/pkg/id/dataset_schema_gen_test.go
@@ -0,0 +1,1004 @@
+// Code generated by gen, DO NOT EDIT.
+
+package id
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/oklog/ulid"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewDatasetSchemaID(t *testing.T) {
+	id := NewDatasetSchemaID()
+	assert.NotNil(t, id)
+	ulID, err := ulid.Parse(id.String())
+
+	assert.NotNil(t, ulID)
+	assert.Nil(t, err)
+}
+
+func TestDatasetSchemaIDFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			result DatasetSchemaID
+			err    error
+		}
+	}{
+		{
+			name:  "Fail:Not valid string",
+			input: "testMustFail",
+			expected: struct {
+				result DatasetSchemaID
+				err    error
+			}{
+				DatasetSchemaID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "Fail:Not valid string",
+			input: "",
+			expected: struct {
+				result DatasetSchemaID
+				err    error
+			}{
+				DatasetSchemaID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "success:valid string",
+			input: "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: struct {
+				result DatasetSchemaID
+				err    error
+			}{
+				DatasetSchemaID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+				nil,
+			},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result, err := DatasetSchemaIDFrom(tc.input)
+			assert.Equal(tt, tc.expected.result, result)
+			if err != nil {
+				assert.True(tt, errors.As(tc.expected.err, &err))
+			}
+		})
+	}
+}
+
+func TestMustDatasetSchemaID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name        string
+		input       string
+		shouldPanic bool
+		expected    DatasetSchemaID
+	}{
+		{
+			name:        "Fail:Not valid string",
+			input:       "testMustFail",
+			shouldPanic: true,
+		},
+		{
+			name:        "Fail:Not valid string",
+			input:       "",
+			shouldPanic: true,
+		},
+		{
+			name:        "success:valid string",
+			input:       "01f2r7kg1fvvffp0gmexgy5hxy",
+			shouldPanic: false,
+			expected:    DatasetSchemaID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.shouldPanic {
+				assert.Panics(tt, func() { MustBeID(tc.input) })
+				return
+			}
+			result := MustDatasetSchemaID(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
+
+func TestDatasetSchemaIDFromRef(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected *DatasetSchemaID
+	}{
+		{
+			name:     "Fail:Not valid string",
+			input:    "testMustFail",
+			expected: nil,
+		},
+		{
+			name:     "Fail:Not valid string",
+			input:    "",
+			expected: nil,
+		},
+		{
+			name:     "success:valid string",
+			input:    "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: &DatasetSchemaID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := DatasetSchemaIDFromRef(&tc.input)
+			assert.Equal(tt, tc.expected, result)
+			if tc.expected != nil {
+				assert.Equal(tt, *tc.expected, *result)
+			}
+		})
+	}
+}
+
+func TestDatasetSchemaIDFromRefID(t *testing.T) {
+	id := New()
+
+	subId := DatasetSchemaIDFromRefID(&id)
+
+	assert.NotNil(t, subId)
+	assert.Equal(t, subId.id, id.id)
+}
+
+func TestDatasetSchemaID_ID(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaIDFromRefID(&id)
+
+	idOrg := subId.ID()
+
+	assert.Equal(t, id, idOrg)
+}
+
+func TestDatasetSchemaID_String(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaIDFromRefID(&id)
+
+	assert.Equal(t, subId.String(), id.String())
+}
+
+func TestDatasetSchemaID_GoString(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaIDFromRefID(&id)
+
+	assert.Equal(t, subId.GoString(), "id.DatasetSchemaID("+id.String()+")")
+}
+
+func TestDatasetSchemaID_RefString(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaIDFromRefID(&id)
+
+	refString := subId.StringRef()
+
+	assert.NotNil(t, refString)
+	assert.Equal(t, *refString, id.String())
+}
+
+func TestDatasetSchemaID_Ref(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaIDFromRefID(&id)
+
+	subIdRef := subId.Ref()
+
+	assert.Equal(t, *subId, *subIdRef)
+}
+
+func TestDatasetSchemaID_CopyRef(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaIDFromRefID(&id)
+
+	subIdCopyRef := subId.CopyRef()
+
+	assert.Equal(t, *subId, *subIdCopyRef)
+	assert.NotSame(t, subId, subIdCopyRef)
+}
+
+func TestDatasetSchemaID_IDRef(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaIDFromRefID(&id)
+
+	assert.Equal(t, id, *subId.IDRef())
+}
+
+func TestDatasetSchemaID_StringRef(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaIDFromRefID(&id)
+
+	assert.Equal(t, *subId.StringRef(), id.String())
+}
+
+func TestDatasetSchemaID_MarhsalJSON(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaIDFromRefID(&id)
+
+	res, err := subId.MarhsalJSON()
+	exp, _ := json.Marshal(subId.String())
+
+	assert.Nil(t, err)
+	assert.Equal(t, exp, res)
+}
+
+func TestDatasetSchemaID_UnmarhsalJSON(t *testing.T) {
+	jsonString := "\"01f3zhkysvcxsnzepyyqtq21fb\""
+
+	subId := &DatasetSchemaID{}
+
+	err := subId.UnmarhsalJSON([]byte(jsonString))
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhkysvcxsnzepyyqtq21fb", subId.String())
+}
+
+func TestDatasetSchemaID_MarshalText(t *testing.T) {
+	id := New()
+	subId := DatasetSchemaIDFromRefID(&id)
+
+	res, err := subId.MarshalText()
+
+	assert.Nil(t, err)
+	assert.Equal(t, []byte(id.String()), res)
+}
+
+func TestDatasetSchemaID_UnmarshalText(t *testing.T) {
+	text := []byte("01f3zhcaq35403zdjnd6dcm0t2")
+
+	subId := &DatasetSchemaID{}
+
+	err := subId.UnmarshalText(text)
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhcaq35403zdjnd6dcm0t2", subId.String())
+
+}
+
+func TestDatasetSchemaID_IsNil(t *testing.T) {
+	subId := DatasetSchemaID{}
+
+	assert.True(t, subId.IsNil())
+
+	id := New()
+	subId = *DatasetSchemaIDFromRefID(&id)
+
+	assert.False(t, subId.IsNil())
+}
+
+func TestDatasetSchemaIDToKeys(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []DatasetSchemaID
+		expected []string
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]DatasetSchemaID, 0),
+			expected: make([]string, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []DatasetSchemaID{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+		},
+		{
+			name: "multiple elements",
+			input: []DatasetSchemaID{
+				MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, DatasetSchemaIDToKeys(tc.input))
+		})
+	}
+
+}
+
+func TestDatasetSchemaIDsFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []string
+		expected struct {
+			res []DatasetSchemaID
+			err error
+		}
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]string, 0),
+			expected: struct {
+				res []DatasetSchemaID
+				err error
+			}{
+				res: make([]DatasetSchemaID, 0),
+				err: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+			expected: struct {
+				res []DatasetSchemaID
+				err error
+			}{
+				res: []DatasetSchemaID{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2")},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []DatasetSchemaID
+				err error
+			}{
+				res: []DatasetSchemaID{
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []DatasetSchemaID
+				err error
+			}{
+				res: nil,
+				err: ErrInvalidID,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.expected.err != nil {
+				_, err := DatasetSchemaIDsFrom(tc.input)
+				assert.True(tt, errors.As(ErrInvalidID, &err))
+			} else {
+				res, err := DatasetSchemaIDsFrom(tc.input)
+				assert.Equal(tt, tc.expected.res, res)
+				assert.Nil(tt, err)
+			}
+
+		})
+	}
+}
+
+func TestDatasetSchemaIDsFromID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []ID
+		expected []DatasetSchemaID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]ID, 0),
+			expected: make([]DatasetSchemaID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []DatasetSchemaID{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []DatasetSchemaID{
+				MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := DatasetSchemaIDsFromID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestDatasetSchemaIDsFromIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+
+	testCases := []struct {
+		name     string
+		input    []*ID
+		expected []DatasetSchemaID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*ID, 0),
+			expected: make([]DatasetSchemaID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*ID{&id1},
+			expected: []DatasetSchemaID{MustDatasetSchemaID(id1.String())},
+		},
+		{
+			name:  "multiple elements",
+			input: []*ID{&id1, &id2, &id3},
+			expected: []DatasetSchemaID{
+				MustDatasetSchemaID(id1.String()),
+				MustDatasetSchemaID(id2.String()),
+				MustDatasetSchemaID(id3.String()),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := DatasetSchemaIDsFromIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestDatasetSchemaIDsToID(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []DatasetSchemaID
+		expected []ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]DatasetSchemaID, 0),
+			expected: make([]ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []DatasetSchemaID{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []DatasetSchemaID{
+				MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := DatasetSchemaIDsToID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestDatasetSchemaIDsToIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	subId1 := MustDatasetSchemaID(id1.String())
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	subId2 := MustDatasetSchemaID(id2.String())
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+	subId3 := MustDatasetSchemaID(id3.String())
+
+	testCases := []struct {
+		name     string
+		input    []*DatasetSchemaID
+		expected []*ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*DatasetSchemaID, 0),
+			expected: make([]*ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*DatasetSchemaID{&subId1},
+			expected: []*ID{&id1},
+		},
+		{
+			name:     "multiple elements",
+			input:    []*DatasetSchemaID{&subId1, &subId2, &subId3},
+			expected: []*ID{&id1, &id2, &id3},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := DatasetSchemaIDsToIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestNewDatasetSchemaIDSet(t *testing.T) {
+	DatasetSchemaIdSet := NewDatasetSchemaIDSet()
+
+	assert.NotNil(t, DatasetSchemaIdSet)
+	assert.Empty(t, DatasetSchemaIdSet.m)
+	assert.Empty(t, DatasetSchemaIdSet.s)
+}
+
+func TestDatasetSchemaIDSet_Add(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []DatasetSchemaID
+		expected *DatasetSchemaIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]DatasetSchemaID, 0),
+			expected: &DatasetSchemaIDSet{
+				m: map[DatasetSchemaID]struct{}{},
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []DatasetSchemaID{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: &DatasetSchemaIDSet{
+				m: map[DatasetSchemaID]struct{}{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetSchemaID{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []DatasetSchemaID{
+				MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &DatasetSchemaIDSet{
+				m: map[DatasetSchemaID]struct{}{
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []DatasetSchemaID{
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+		{
+			name: "multiple elements with duplication",
+			input: []DatasetSchemaID{
+				MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &DatasetSchemaIDSet{
+				m: map[DatasetSchemaID]struct{}{
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []DatasetSchemaID{
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewDatasetSchemaIDSet()
+			set.Add(tc.input...)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestDatasetSchemaIDSet_AddRef(t *testing.T) {
+	t.Parallel()
+
+	DatasetSchemaId := MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1")
+
+	testCases := []struct {
+		name     string
+		input    *DatasetSchemaID
+		expected *DatasetSchemaIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: nil,
+			expected: &DatasetSchemaIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: &DatasetSchemaId,
+			expected: &DatasetSchemaIDSet{
+				m: map[DatasetSchemaID]struct{}{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetSchemaID{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewDatasetSchemaIDSet()
+			set.AddRef(tc.input)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestDatasetSchemaIDSet_Has(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			DatasetSchemaIDSet
+			DatasetSchemaID
+		}
+		expected bool
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				DatasetSchemaIDSet
+				DatasetSchemaID
+			}{DatasetSchemaIDSet: DatasetSchemaIDSet{}, DatasetSchemaID: MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: false,
+		},
+		{
+			name: "Set Contains the element",
+			input: struct {
+				DatasetSchemaIDSet
+				DatasetSchemaID
+			}{DatasetSchemaIDSet: DatasetSchemaIDSet{
+				m: map[DatasetSchemaID]struct{}{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetSchemaID{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, DatasetSchemaID: MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: true,
+		},
+		{
+			name: "Set does not Contains the element",
+			input: struct {
+				DatasetSchemaIDSet
+				DatasetSchemaID
+			}{DatasetSchemaIDSet: DatasetSchemaIDSet{
+				m: map[DatasetSchemaID]struct{}{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetSchemaID{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, DatasetSchemaID: MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, tc.input.DatasetSchemaIDSet.Has(tc.input.DatasetSchemaID))
+		})
+	}
+}
+
+func TestDatasetSchemaIDSet_Clear(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    DatasetSchemaIDSet
+		expected DatasetSchemaIDSet
+	}{
+		{
+			name:  "Empty Set",
+			input: DatasetSchemaIDSet{},
+			expected: DatasetSchemaIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name: "Set Contains the element",
+			input: DatasetSchemaIDSet{
+				m: map[DatasetSchemaID]struct{}{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetSchemaID{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: DatasetSchemaIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			set := tc.input
+			p := &set
+			p.Clear()
+			assert.Equal(tt, tc.expected, *p)
+		})
+	}
+}
+
+func TestDatasetSchemaIDSet_All(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *DatasetSchemaIDSet
+		expected []DatasetSchemaID
+	}{
+		{
+			name: "Empty slice",
+			input: &DatasetSchemaIDSet{
+				m: map[DatasetSchemaID]struct{}{},
+				s: nil,
+			},
+			expected: make([]DatasetSchemaID, 0),
+		},
+		{
+			name: "1 element",
+			input: &DatasetSchemaIDSet{
+				m: map[DatasetSchemaID]struct{}{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetSchemaID{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: []DatasetSchemaID{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1")},
+		},
+		{
+			name: "multiple elements",
+			input: &DatasetSchemaIDSet{
+				m: map[DatasetSchemaID]struct{}{
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []DatasetSchemaID{
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: []DatasetSchemaID{
+				MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.All())
+		})
+	}
+}
+
+func TestDatasetSchemaIDSet_Clone(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *DatasetSchemaIDSet
+		expected *DatasetSchemaIDSet
+	}{
+		{
+			name:     "nil set",
+			input:    nil,
+			expected: NewDatasetSchemaIDSet(),
+		},
+		{
+			name:     "Empty set",
+			input:    NewDatasetSchemaIDSet(),
+			expected: NewDatasetSchemaIDSet(),
+		},
+		{
+			name: "1 element",
+			input: &DatasetSchemaIDSet{
+				m: map[DatasetSchemaID]struct{}{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetSchemaID{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: &DatasetSchemaIDSet{
+				m: map[DatasetSchemaID]struct{}{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetSchemaID{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: &DatasetSchemaIDSet{
+				m: map[DatasetSchemaID]struct{}{
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []DatasetSchemaID{
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: &DatasetSchemaIDSet{
+				m: map[DatasetSchemaID]struct{}{
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []DatasetSchemaID{
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			clone := tc.input.Clone()
+			assert.Equal(tt, tc.expected, clone)
+			assert.False(tt, tc.input == clone)
+		})
+	}
+}
+
+func TestDatasetSchemaIDSet_Merge(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			a *DatasetSchemaIDSet
+			b *DatasetSchemaIDSet
+		}
+		expected *DatasetSchemaIDSet
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				a *DatasetSchemaIDSet
+				b *DatasetSchemaIDSet
+			}{
+				a: &DatasetSchemaIDSet{},
+				b: &DatasetSchemaIDSet{},
+			},
+			expected: &DatasetSchemaIDSet{},
+		},
+		{
+			name: "1 Empty Set",
+			input: struct {
+				a *DatasetSchemaIDSet
+				b *DatasetSchemaIDSet
+			}{
+				a: &DatasetSchemaIDSet{
+					m: map[DatasetSchemaID]struct{}{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []DatasetSchemaID{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &DatasetSchemaIDSet{},
+			},
+			expected: &DatasetSchemaIDSet{
+				m: map[DatasetSchemaID]struct{}{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []DatasetSchemaID{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "2 non Empty Set",
+			input: struct {
+				a *DatasetSchemaIDSet
+				b *DatasetSchemaIDSet
+			}{
+				a: &DatasetSchemaIDSet{
+					m: map[DatasetSchemaID]struct{}{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []DatasetSchemaID{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &DatasetSchemaIDSet{
+					m: map[DatasetSchemaID]struct{}{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{}},
+					s: []DatasetSchemaID{MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2")},
+				},
+			},
+			expected: &DatasetSchemaIDSet{
+				m: map[DatasetSchemaID]struct{}{
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+				},
+				s: []DatasetSchemaID{
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustDatasetSchemaID("01f3zhcaq35403zdjnd6dcm0t2"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.a.Merge(tc.input.b))
+		})
+	}
+}
diff --git a/pkg/id/gen.go b/pkg/id/gen.go
index a14d534d..54d0703b 100644
--- a/pkg/id/gen.go
+++ b/pkg/id/gen.go
@@ -9,5 +9,22 @@
 //go:generate go run github.com/reearth/reearth-backend/tools/cmd/gen --template=id.tmpl --output=widget_gen.go --name=Widget
 //go:generate go run github.com/reearth/reearth-backend/tools/cmd/gen --template=id.tmpl --output=team_gen.go --name=Team
 //go:generate go run github.com/reearth/reearth-backend/tools/cmd/gen --template=id.tmpl --output=user_gen.go --name=User
+//go:generate go run github.com/reearth/reearth-backend/tools/cmd/gen --template=id.tmpl --output=dataset_schema_field_gen.go --name=DatasetSchemaField
+//go:generate go run github.com/reearth/reearth-backend/tools/cmd/gen --template=id.tmpl --output=infobox_field_gen.go --name=InfoboxField
+
+// Testing
+//go:generate go run github.com/reearth/reearth-backend/tools/cmd/gen --template=id_test.tmpl --output=asset_gen_test.go --name=Asset
+//go:generate go run github.com/reearth/reearth-backend/tools/cmd/gen --template=id_test.tmpl --output=dataset_gen_test.go --name=Dataset
+//go:generate go run github.com/reearth/reearth-backend/tools/cmd/gen --template=id_test.tmpl --output=dataset_schema_gen_test.go --name=DatasetSchema
+//go:generate go run github.com/reearth/reearth-backend/tools/cmd/gen --template=id_test.tmpl --output=layer_gen_test.go --name=Layer
+//go:generate go run github.com/reearth/reearth-backend/tools/cmd/gen --template=id_test.tmpl --output=project_gen_test.go --name=Project
+//go:generate go run github.com/reearth/reearth-backend/tools/cmd/gen --template=id_test.tmpl --output=property_gen_test.go --name=Property
+//go:generate go run github.com/reearth/reearth-backend/tools/cmd/gen --template=id_test.tmpl --output=property_item_gen_test.go --name=PropertyItem
+//go:generate go run github.com/reearth/reearth-backend/tools/cmd/gen --template=id_test.tmpl --output=scene_gen_test.go --name=Scene
+//go:generate go run github.com/reearth/reearth-backend/tools/cmd/gen --template=id_test.tmpl --output=widget_gen_test.go --name=Widget
+//go:generate go run github.com/reearth/reearth-backend/tools/cmd/gen --template=id_test.tmpl --output=team_gen_test.go --name=Team
+//go:generate go run github.com/reearth/reearth-backend/tools/cmd/gen --template=id_test.tmpl --output=user_gen_test.go --name=User
+//go:generate go run github.com/reearth/reearth-backend/tools/cmd/gen --template=id_test.tmpl --output=dataset_schema_field_gen_test.go --name=DatasetSchemaField
+//go:generate go run github.com/reearth/reearth-backend/tools/cmd/gen --template=id_test.tmpl --output=infobox_field_gen_test.go --name=InfoboxField
 
 package id
diff --git a/pkg/id/id_test.go b/pkg/id/id_test.go
new file mode 100644
index 00000000..2becc4dc
--- /dev/null
+++ b/pkg/id/id_test.go
@@ -0,0 +1,373 @@
+package id
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/oklog/ulid"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestID_New(t *testing.T) {
+	id := New()
+	assert.NotNil(t, id)
+	ulID, err := ulid.Parse(id.String())
+
+	assert.NotNil(t, ulID)
+	assert.Nil(t, err)
+}
+
+func TestID_NewAllID(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    int
+		expected int
+	}{
+		{
+			name:     "success: Zero ID",
+			input:    0,
+			expected: 0,
+		},
+		{
+			name:     "success: One ID",
+			input:    1,
+			expected: 1,
+		},
+		{
+			name:     "success: Multiple IDs",
+			input:    5,
+			expected: 5,
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := NewAllID(tc.input)
+			assert.Equal(tt, tc.expected, len(result))
+			for _, id := range result {
+				assert.NotNil(t, id)
+				ulID, err := ulid.Parse(id.String())
+
+				assert.NotNil(t, ulID)
+				assert.Nil(t, err)
+			}
+		})
+	}
+}
+
+func TestID_NewIDWith(t *testing.T) {
+	testCases := []struct {
+		name  string
+		input string
+	}{
+		{
+			name:  "Fail:Not valid string",
+			input: "testMustFail",
+		},
+		{
+			name:  "Fail:Not valid string",
+			input: "",
+		},
+		{
+			name:  "success:valid string",
+			input: "01f2r7kg1fvvffp0gmexgy5hxy",
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result, err := NewIDWith(tc.input)
+			exResult, exErr := FromID(tc.input)
+			assert.Equal(tt, exResult, result)
+			assert.Equal(tt, exErr, err)
+		})
+	}
+}
+
+func TestID_FromID(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			result ID
+			err    error
+		}
+	}{
+		{
+			name:  "Fail:Not valid string",
+			input: "testMustFail",
+			expected: struct {
+				result ID
+				err    error
+			}{
+				ID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "Fail:Not valid string",
+			input: "",
+			expected: struct {
+				result ID
+				err    error
+			}{
+				ID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "success:valid string",
+			input: "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: struct {
+				result ID
+				err    error
+			}{
+				ID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+				nil,
+			},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result, err := FromID(tc.input)
+			assert.Equal(tt, tc.expected.result, result)
+			if err != nil {
+				assert.True(tt, errors.As(tc.expected.err, &err))
+			}
+		})
+	}
+}
+
+func TestID_FromIDRef(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected *ID
+	}{
+		{
+			name:     "Fail:Not valid string",
+			input:    "testMustFail",
+			expected: nil,
+		},
+		{
+			name:     "Fail:Not valid string",
+			input:    "",
+			expected: nil,
+		},
+		{
+			name:     "success:valid string",
+			input:    "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: &ID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := FromIDRef(&tc.input)
+			assert.Equal(tt, tc.expected, result)
+			if tc.expected != nil {
+				assert.Equal(tt, *tc.expected, *result)
+			}
+		})
+	}
+}
+
+func TestID_MustBeID(t *testing.T) {
+	testCases := []struct {
+		name        string
+		input       string
+		shouldPanic bool
+		expected    ID
+	}{
+		{
+			name:        "Fail:Not valid string",
+			input:       "testMustFail",
+			shouldPanic: true,
+		},
+		{
+			name:        "Fail:Not valid string",
+			input:       "",
+			shouldPanic: true,
+		},
+		{
+			name:        "success:valid string",
+			input:       "01f2r7kg1fvvffp0gmexgy5hxy",
+			shouldPanic: false,
+			expected:    ID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.shouldPanic {
+				assert.Panics(tt, func() { MustBeID(tc.input) })
+				return
+			}
+			result := MustBeID(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
+
+func TestID_Copy(t *testing.T) {
+	id := New()
+
+	id2 := id.Copy()
+
+	assert.Equal(t, id.id, id2.id)
+
+	assert.NotSame(t, id.id, id2.id)
+}
+
+func TestID_Timestamp(t *testing.T) {
+	id := New()
+
+	assert.Equal(t, ulid.Time(id.id.Time()), id.Timestamp())
+}
+
+func TestID_String(t *testing.T) {
+	id := MustBeID("01f2r7kg1fvvffp0gmexgy5hxy")
+
+	assert.Equal(t, id.String(), "01f2r7kg1fvvffp0gmexgy5hxy")
+}
+
+func TestID_GoString(t *testing.T) {
+	id := MustBeID("01f2r7kg1fvvffp0gmexgy5hxy")
+
+	assert.Equal(t, id.GoString(), "id.ID(01f2r7kg1fvvffp0gmexgy5hxy)")
+}
+
+func TestID_IsNil(t *testing.T) {
+	id := ID{}
+
+	assert.True(t, id.IsNil())
+
+	id = New()
+
+	assert.False(t, id.IsNil())
+
+}
+
+func TestID_Compare(t *testing.T) {
+	id1 := New()
+	id2 := New()
+
+	assert.Less(t, id1.Compare(id2), 0)
+	assert.Greater(t, id2.Compare(id1), 0)
+	assert.Equal(t, id1.Compare(id1), 0)
+	assert.Equal(t, id2.Compare(id2), 0)
+}
+
+func TestID_Equal(t *testing.T) {
+	id1 := New()
+	id2 := id1.Copy()
+
+	assert.True(t, id1.Equal(id2))
+	assert.False(t, id1.Equal(New()))
+}
+
+func TestID_IsEmpty(t *testing.T) {
+	id := ID{}
+
+	assert.True(t, id.IsEmpty())
+
+	id = New()
+
+	assert.False(t, id.IsEmpty())
+}
+
+func TestID_generateID(t *testing.T) {
+	id := generateID()
+
+	assert.NotNil(t, id)
+}
+
+func TestID_generateAllID(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    int
+		expected int
+	}{
+		{
+			name:     "success: Zero ID",
+			input:    0,
+			expected: 0,
+		},
+		{
+			name:     "success: One ID",
+			input:    1,
+			expected: 1,
+		},
+		{
+			name:     "success: Multiple IDs",
+			input:    5,
+			expected: 5,
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := generateAllID(tc.input)
+			assert.Equal(tt, tc.expected, len(result))
+			for _, id := range result {
+				assert.NotNil(t, id)
+				ulID, err := ulid.Parse(id.String())
+
+				assert.NotNil(t, ulID)
+				assert.Nil(t, err)
+			}
+		})
+	}
+}
+
+func TestID_parseID(t *testing.T) {
+	_, err := parseID("")
+
+	assert.True(t, errors.As(ErrInvalidID, &err))
+
+	id, err := parseID("01f2r7kg1fvvffp0gmexgy5hxy")
+
+	assert.Nil(t, err)
+	assert.EqualValues(t, strings.ToLower(id.String()), "01f2r7kg1fvvffp0gmexgy5hxy")
+}
+
+func TestID_includeUpperCase(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected bool
+	}{
+		{
+			name:     "All small letters",
+			input:    "abcd",
+			expected: false,
+		},
+		{
+			name:     "Contains Upper case",
+			input:    "Abcd",
+			expected: true,
+		},
+		{
+			name:     "Contains Upper case",
+			input:    "abcD",
+			expected: true,
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := includeUpperCase(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
diff --git a/pkg/id/id_test.tmpl b/pkg/id/id_test.tmpl
new file mode 100644
index 00000000..98b41c96
--- /dev/null
+++ b/pkg/id/id_test.tmpl
@@ -0,0 +1,1006 @@
+{{ $name := index .Flags.name 0 }}
+
+package {{.PackageName}}
+
+import (
+	"encoding"
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/blang/semver"
+	"github.com/stretchr/testify/assert"
+)
+
+
+func TestNew{{$name}}ID(t *testing.T) {
+	id := New{{$name}}ID()
+    assert.NotNil(t, id)
+    ulID, err := ulid.Parse(id.String())
+
+    assert.NotNil(t, ulID)
+    assert.Nil(t, err)
+}
+
+func Test{{$name}}IDFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			result {{$name}}ID
+			err    error
+		}
+	}{
+		{
+			name:  "Fail:Not valid string",
+			input: "testMustFail",
+			expected: struct {
+				result {{$name}}ID
+				err    error
+			}{
+				{{$name}}ID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "Fail:Not valid string",
+			input: "",
+			expected: struct {
+				result {{$name}}ID
+				err    error
+			}{
+				{{$name}}ID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "success:valid string",
+			input: "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: struct {
+				result {{$name}}ID
+				err    error
+			}{
+				{{$name}}ID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+				nil,
+			},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result, err := {{$name}}IDFrom(tc.input)
+			assert.Equal(tt, tc.expected.result, result)
+			if err != nil {
+				assert.True(tt, errors.As(tc.expected.err, &err))
+			}
+		})
+	}
+}
+
+func TestMust{{$name}}ID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name        string
+		input       string
+		shouldPanic bool
+		expected    {{$name}}ID
+	}{
+		{
+			name:        "Fail:Not valid string",
+			input:       "testMustFail",
+			shouldPanic: true,
+		},
+		{
+			name:        "Fail:Not valid string",
+			input:       "",
+			shouldPanic: true,
+		},
+		{
+			name:        "success:valid string",
+			input:       "01f2r7kg1fvvffp0gmexgy5hxy",
+			shouldPanic: false,
+			expected:    {{$name}}ID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.shouldPanic {
+				assert.Panics(tt, func() { MustBeID(tc.input) })
+				return
+			}
+			result := Must{{$name}}ID(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
+
+func Test{{$name}}IDFromRef(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected *{{$name}}ID
+	}{
+		{
+			name:     "Fail:Not valid string",
+			input:    "testMustFail",
+			expected: nil,
+		},
+		{
+			name:     "Fail:Not valid string",
+			input:    "",
+			expected: nil,
+		},
+		{
+			name:     "success:valid string",
+			input:    "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: &{{$name}}ID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := {{$name}}IDFromRef(&tc.input)
+			assert.Equal(tt, tc.expected, result)
+			if tc.expected != nil {
+				assert.Equal(tt, *tc.expected, *result)
+			}
+		})
+	}
+}
+
+func Test{{$name}}IDFromRefID(t *testing.T) {
+	id := New()
+
+	subId := {{$name}}IDFromRefID(&id)
+
+	assert.NotNil(t, subId)
+	assert.Equal(t, subId.id, id.id)
+}
+
+func Test{{$name}}ID_ID(t *testing.T) {
+	id := New()
+	subId := {{$name}}IDFromRefID(&id)
+
+	idOrg := subId.ID()
+
+	assert.Equal(t, id, idOrg)
+}
+
+func Test{{$name}}ID_String(t *testing.T) {
+	id := New()
+	subId := {{$name}}IDFromRefID(&id)
+
+	assert.Equal(t, subId.String(), id.String())
+}
+
+func Test{{$name}}ID_GoString(t *testing.T) {
+	id := New()
+	subId := {{$name}}IDFromRefID(&id)
+
+	assert.Equal(t, subId.GoString(), "id.{{$name}}ID(" + id.String() + ")")
+}
+
+func Test{{$name}}ID_RefString(t *testing.T) {
+	id := New()
+	subId := {{$name}}IDFromRefID(&id)
+
+	refString := subId.StringRef()
+
+	assert.NotNil(t, refString)
+	assert.Equal(t, *refString, id.String())
+}
+
+func Test{{$name}}ID_Ref(t *testing.T) {
+	id := New()
+	subId := {{$name}}IDFromRefID(&id)
+
+	subIdRef := subId.Ref()
+
+	assert.Equal(t, *subId, *subIdRef)
+}
+
+func Test{{$name}}ID_CopyRef(t *testing.T) {
+	id := New()
+	subId := {{$name}}IDFromRefID(&id)
+
+	subIdCopyRef := subId.CopyRef()
+
+	assert.Equal(t, *subId, *subIdCopyRef)
+	assert.NotSame(t, subId, subIdCopyRef)
+}
+
+func Test{{$name}}ID_IDRef(t *testing.T) {
+	id := New()
+	subId := {{$name}}IDFromRefID(&id)
+
+	assert.Equal(t, id, *subId.IDRef())
+}
+
+func Test{{$name}}ID_StringRef(t *testing.T) {
+	id := New()
+	subId := {{$name}}IDFromRefID(&id)
+
+	assert.Equal(t, *subId.StringRef(), id.String())
+}
+
+func Test{{$name}}ID_MarhsalJSON(t *testing.T) {
+	id := New()
+	subId := {{$name}}IDFromRefID(&id)
+
+	res, err := subId.MarhsalJSON()
+	exp, _ := json.Marshal(subId.String())
+
+	assert.Nil(t, err)
+	assert.Equal(t, exp, res)
+}
+
+func Test{{$name}}ID_UnmarhsalJSON(t *testing.T) {
+	jsonString := "\"01f3zhkysvcxsnzepyyqtq21fb\""
+
+	subId := &{{$name}}ID{}
+
+	err := subId.UnmarhsalJSON([]byte(jsonString))
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhkysvcxsnzepyyqtq21fb", subId.String())
+}
+
+func Test{{$name}}ID_MarshalText(t *testing.T) {
+	id := New()
+	subId := {{$name}}IDFromRefID(&id)
+
+	res, err := subId.MarshalText()
+
+	assert.Nil(t, err)
+	assert.Equal(t, []byte(id.String()), res)
+}
+
+func Test{{$name}}ID_UnmarshalText(t *testing.T) {
+	text := []byte("01f3zhcaq35403zdjnd6dcm0t2")
+
+	subId := &{{$name}}ID{}
+
+	err := subId.UnmarshalText(text)
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhcaq35403zdjnd6dcm0t2", subId.String())
+
+}
+
+func Test{{$name}}ID_IsNil(t *testing.T) {
+	subId := {{$name}}ID{}
+
+	assert.True(t, subId.IsNil())
+
+	id := New()
+	subId = *{{$name}}IDFromRefID(&id)
+
+	assert.False(t, subId.IsNil())
+}
+
+func Test{{$name}}IDToKeys(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []{{$name}}ID
+		expected []string
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]{{$name}}ID, 0),
+			expected: make([]string, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []{{$name}}ID{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+		},
+		{
+			name: "multiple elements",
+			input: []{{$name}}ID{
+				Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"),
+				Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2"),
+				Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, {{$name}}IDToKeys(tc.input))
+		})
+	}
+
+}
+
+func Test{{$name}}IDsFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []string
+		expected struct {
+			res []{{$name}}ID
+			err error
+		}
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]string, 0),
+			expected: struct {
+				res []{{$name}}ID
+				err error
+			}{
+				res: make([]{{$name}}ID, 0),
+				err: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+			expected: struct {
+				res []{{$name}}ID
+				err error
+			}{
+				res: []{{$name}}ID{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2")},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []{{$name}}ID
+				err error
+			}{
+				res: []{{$name}}ID{
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"),
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2"),
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []{{$name}}ID
+				err error
+			}{
+				res: nil,
+				err: ErrInvalidID,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.expected.err != nil {
+				_, err := {{$name}}IDsFrom(tc.input)
+				assert.True(tt, errors.As(ErrInvalidID, &err))
+			} else {
+				res, err := {{$name}}IDsFrom(tc.input)
+				assert.Equal(tt, tc.expected.res, res)
+				assert.Nil(tt, err)
+			}
+
+		})
+	}
+}
+
+func Test{{$name}}IDsFromID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []ID
+		expected []{{$name}}ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]ID, 0),
+			expected: make([]{{$name}}ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []{{$name}}ID{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []{{$name}}ID{
+				Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"),
+				Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2"),
+				Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := {{$name}}IDsFromID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func Test{{$name}}IDsFromIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+
+	testCases := []struct {
+		name     string
+		input    []*ID
+		expected []{{$name}}ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*ID, 0),
+			expected: make([]{{$name}}ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*ID{&id1},
+			expected: []{{$name}}ID{Must{{$name}}ID(id1.String())},
+		},
+		{
+			name:  "multiple elements",
+			input: []*ID{&id1, &id2, &id3},
+			expected: []{{$name}}ID{
+				Must{{$name}}ID(id1.String()),
+				Must{{$name}}ID(id2.String()),
+				Must{{$name}}ID(id3.String()),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := {{$name}}IDsFromIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func Test{{$name}}IDsToID(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []{{$name}}ID
+		expected []ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]{{$name}}ID, 0),
+			expected: make([]ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []{{$name}}ID{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []{{$name}}ID{
+				Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"),
+				Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2"),
+				Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := {{$name}}IDsToID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func Test{{$name}}IDsToIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	subId1 := Must{{$name}}ID(id1.String())
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	subId2 := Must{{$name}}ID(id2.String())
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+	subId3 := Must{{$name}}ID(id3.String())
+
+	testCases := []struct {
+		name     string
+		input    []*{{$name}}ID
+		expected []*ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*{{$name}}ID, 0),
+			expected: make([]*ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*{{$name}}ID{&subId1},
+			expected: []*ID{&id1},
+		},
+		{
+			name:     "multiple elements",
+			input:    []*{{$name}}ID{&subId1, &subId2, &subId3},
+			expected: []*ID{&id1, &id2, &id3},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := {{$name}}IDsToIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestNew{{$name}}IDSet(t *testing.T) {
+	{{$name}}IdSet := New{{$name}}IDSet()
+
+	assert.NotNil(t, {{$name}}IdSet)
+	assert.Empty(t, {{$name}}IdSet.m)
+	assert.Empty(t, {{$name}}IdSet.s)
+}
+
+func Test{{$name}}IDSet_Add(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []{{$name}}ID
+		expected *{{$name}}IDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]{{$name}}ID, 0),
+			expected: &{{$name}}IDSet{
+				m: map[{{$name}}ID]struct{}{},
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []{{$name}}ID{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: &{{$name}}IDSet{
+				m: map[{{$name}}ID]struct{}{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []{{$name}}ID{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []{{$name}}ID{
+				Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"),
+				Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2"),
+				Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &{{$name}}IDSet{
+				m: map[{{$name}}ID]struct{}{
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []{{$name}}ID{
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"),
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2"),
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+		{
+			name: "multiple elements with duplication",
+			input: []{{$name}}ID{
+				Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"),
+				Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"),
+				Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &{{$name}}IDSet{
+				m: map[{{$name}}ID]struct{}{
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []{{$name}}ID{
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"),
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := New{{$name}}IDSet()
+			set.Add(tc.input...)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func Test{{$name}}IDSet_AddRef(t *testing.T) {
+	t.Parallel()
+
+	{{$name}}Id := Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1")
+
+	testCases := []struct {
+		name     string
+		input    *{{$name}}ID
+		expected *{{$name}}IDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: nil,
+			expected: &{{$name}}IDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: &{{$name}}Id,
+			expected: &{{$name}}IDSet{
+				m: map[{{$name}}ID]struct{}{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []{{$name}}ID{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := New{{$name}}IDSet()
+			set.AddRef(tc.input)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func Test{{$name}}IDSet_Has(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			{{$name}}IDSet
+			{{$name}}ID
+		}
+		expected bool
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				{{$name}}IDSet
+				{{$name}}ID
+			}{ {{$name}}IDSet: {{$name}}IDSet{}, {{$name}}ID: Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: false,
+		},
+		{
+			name: "Set Contains the element",
+			input: struct {
+				{{$name}}IDSet
+				{{$name}}ID
+			}{ {{$name}}IDSet: {{$name}}IDSet{
+				m: map[{{$name}}ID]struct{}{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []{{$name}}ID{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, {{$name}}ID: Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: true,
+		},
+		{
+			name: "Set does not Contains the element",
+			input: struct {
+				{{$name}}IDSet
+				{{$name}}ID
+			}{ {{$name}}IDSet: {{$name}}IDSet{
+				m: map[{{$name}}ID]struct{}{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []{{$name}}ID{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, {{$name}}ID: Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, tc.input.{{$name}}IDSet.Has(tc.input.{{$name}}ID))
+		})
+	}
+}
+
+func Test{{$name}}IDSet_Clear(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    {{$name}}IDSet
+		expected {{$name}}IDSet
+	}{
+		{
+			name:  "Empty Set",
+			input: {{$name}}IDSet{},
+			expected: {{$name}}IDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name: "Set Contains the element",
+			input: {{$name}}IDSet{
+				m: map[{{$name}}ID]struct{}{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []{{$name}}ID{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: {{$name}}IDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			set := tc.input
+			p := &set
+			p.Clear()
+			assert.Equal(tt, tc.expected, *p)
+		})
+	}
+}
+
+func Test{{$name}}IDSet_All(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *{{$name}}IDSet
+		expected []{{$name}}ID
+	}{
+		{
+			name: "Empty slice",
+			input: &{{$name}}IDSet{
+				m: map[{{$name}}ID]struct{}{},
+				s: nil,
+			},
+			expected: make([]{{$name}}ID, 0),
+		},
+		{
+			name: "1 element",
+			input: &{{$name}}IDSet{
+				m: map[{{$name}}ID]struct{}{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []{{$name}}ID{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: []{{$name}}ID{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1")},
+		},
+		{
+			name: "multiple elements",
+			input: &{{$name}}IDSet{
+				m: map[{{$name}}ID]struct{}{
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []{{$name}}ID{
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"),
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2"),
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: []{{$name}}ID{
+				Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"),
+				Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2"),
+				Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.All())
+		})
+	}
+}
+
+func Test{{$name}}IDSet_Clone(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *{{$name}}IDSet
+		expected *{{$name}}IDSet
+	}{
+		{
+			name:     "nil set",
+			input:    nil,
+			expected: New{{$name}}IDSet(),
+		},
+		{
+			name:     "Empty set",
+			input:    New{{$name}}IDSet(),
+			expected: New{{$name}}IDSet(),
+		},
+		{
+			name: "1 element",
+			input: &{{$name}}IDSet{
+				m: map[{{$name}}ID]struct{}{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []{{$name}}ID{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: &{{$name}}IDSet{
+				m: map[{{$name}}ID]struct{}{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []{{$name}}ID{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: &{{$name}}IDSet{
+				m: map[{{$name}}ID]struct{}{
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []{{$name}}ID{
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"),
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2"),
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: &{{$name}}IDSet{
+				m: map[{{$name}}ID]struct{}{
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []{{$name}}ID{
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"),
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2"),
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			clone := tc.input.Clone()
+			assert.Equal(tt, tc.expected, clone)
+			assert.False(tt, tc.input == clone)
+		})
+	}
+}
+
+func Test{{$name}}IDSet_Merge(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			a *{{$name}}IDSet
+			b *{{$name}}IDSet
+		}
+		expected *{{$name}}IDSet
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				a *{{$name}}IDSet
+				b *{{$name}}IDSet
+			}{
+				a: &{{$name}}IDSet{},
+				b: &{{$name}}IDSet{},
+			},
+			expected: &{{$name}}IDSet{},
+		},
+		{
+			name: "1 Empty Set",
+			input: struct {
+				a *{{$name}}IDSet
+				b *{{$name}}IDSet
+			}{
+				a: &{{$name}}IDSet{
+					m: map[{{$name}}ID]struct{}{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []{{$name}}ID{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &{{$name}}IDSet{},
+			},
+			expected: &{{$name}}IDSet{
+				m: map[{{$name}}ID]struct{}{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []{{$name}}ID{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "2 non Empty Set",
+			input: struct {
+				a *{{$name}}IDSet
+				b *{{$name}}IDSet
+			}{
+				a: &{{$name}}IDSet{
+					m: map[{{$name}}ID]struct{}{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []{{$name}}ID{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &{{$name}}IDSet{
+					m: map[{{$name}}ID]struct{}{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{}},
+					s: []{{$name}}ID{Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2")},
+				},
+			},
+			expected: &{{$name}}IDSet{
+				m: map[{{$name}}ID]struct{}{
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+				},
+				s: []{{$name}}ID{
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t1"),
+					Must{{$name}}ID("01f3zhcaq35403zdjnd6dcm0t2"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.a.Merge(tc.input.b))
+		})
+	}
+}
diff --git a/pkg/id/infobox_field_gen.go b/pkg/id/infobox_field_gen.go
index 408b04af..189646e2 100644
--- a/pkg/id/infobox_field_gen.go
+++ b/pkg/id/infobox_field_gen.go
@@ -1,7 +1,9 @@
-// Code generated by idgen, DO NOT EDIT.
+// Code generated by gen, DO NOT EDIT.
 
 package id
 
+import "encoding/json"
+
 // InfoboxFieldID is an ID for InfoboxField.
 type InfoboxFieldID ID
 
@@ -59,6 +61,11 @@ func (d InfoboxFieldID) String() string {
 	return ID(d).String()
 }
 
+// GoString implements fmt.GoStringer interface.
+func (d InfoboxFieldID) GoString() string {
+	return "id.InfoboxFieldID(" + d.String() + ")"
+}
+
 // RefString returns a reference of string representation.
 func (d InfoboxFieldID) RefString() *string {
 	id := ID(d).String()
@@ -98,6 +105,35 @@ func (d *InfoboxFieldID) StringRef() *string {
 	return &id
 }
 
+// MarhsalJSON implements json.Marhsaler interface
+func (d *InfoboxFieldID) MarhsalJSON() ([]byte, error) {
+	return json.Marshal(d.String())
+}
+
+// UnmarhsalJSON implements json.Unmarshaler interface
+func (d *InfoboxFieldID) UnmarhsalJSON(bs []byte) (err error) {
+	var idstr string
+	if err = json.Unmarshal(bs, &idstr); err != nil {
+		return
+	}
+	*d, err = InfoboxFieldIDFrom(idstr)
+	return
+}
+
+// MarshalText implements encoding.TextMarshaler interface
+func (d *InfoboxFieldID) MarshalText() ([]byte, error) {
+	if d == nil {
+		return nil, nil
+	}
+	return []byte(d.String()), nil
+}
+
+// UnmarshalText implements encoding.TextUnmarshaler interface
+func (d *InfoboxFieldID) UnmarshalText(text []byte) (err error) {
+	*d, err = InfoboxFieldIDFrom(string(text))
+	return
+}
+
 // Ref returns true if a ID is nil or zero-value
 func (d InfoboxFieldID) IsNil() bool {
 	return ID(d).IsNil()
diff --git a/pkg/id/infobox_field_gen_test.go b/pkg/id/infobox_field_gen_test.go
new file mode 100644
index 00000000..89b02356
--- /dev/null
+++ b/pkg/id/infobox_field_gen_test.go
@@ -0,0 +1,1004 @@
+// Code generated by gen, DO NOT EDIT.
+
+package id
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/oklog/ulid"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewInfoboxFieldID(t *testing.T) {
+	id := NewInfoboxFieldID()
+	assert.NotNil(t, id)
+	ulID, err := ulid.Parse(id.String())
+
+	assert.NotNil(t, ulID)
+	assert.Nil(t, err)
+}
+
+func TestInfoboxFieldIDFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			result InfoboxFieldID
+			err    error
+		}
+	}{
+		{
+			name:  "Fail:Not valid string",
+			input: "testMustFail",
+			expected: struct {
+				result InfoboxFieldID
+				err    error
+			}{
+				InfoboxFieldID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "Fail:Not valid string",
+			input: "",
+			expected: struct {
+				result InfoboxFieldID
+				err    error
+			}{
+				InfoboxFieldID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "success:valid string",
+			input: "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: struct {
+				result InfoboxFieldID
+				err    error
+			}{
+				InfoboxFieldID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+				nil,
+			},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result, err := InfoboxFieldIDFrom(tc.input)
+			assert.Equal(tt, tc.expected.result, result)
+			if err != nil {
+				assert.True(tt, errors.As(tc.expected.err, &err))
+			}
+		})
+	}
+}
+
+func TestMustInfoboxFieldID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name        string
+		input       string
+		shouldPanic bool
+		expected    InfoboxFieldID
+	}{
+		{
+			name:        "Fail:Not valid string",
+			input:       "testMustFail",
+			shouldPanic: true,
+		},
+		{
+			name:        "Fail:Not valid string",
+			input:       "",
+			shouldPanic: true,
+		},
+		{
+			name:        "success:valid string",
+			input:       "01f2r7kg1fvvffp0gmexgy5hxy",
+			shouldPanic: false,
+			expected:    InfoboxFieldID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.shouldPanic {
+				assert.Panics(tt, func() { MustBeID(tc.input) })
+				return
+			}
+			result := MustInfoboxFieldID(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
+
+func TestInfoboxFieldIDFromRef(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected *InfoboxFieldID
+	}{
+		{
+			name:     "Fail:Not valid string",
+			input:    "testMustFail",
+			expected: nil,
+		},
+		{
+			name:     "Fail:Not valid string",
+			input:    "",
+			expected: nil,
+		},
+		{
+			name:     "success:valid string",
+			input:    "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: &InfoboxFieldID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := InfoboxFieldIDFromRef(&tc.input)
+			assert.Equal(tt, tc.expected, result)
+			if tc.expected != nil {
+				assert.Equal(tt, *tc.expected, *result)
+			}
+		})
+	}
+}
+
+func TestInfoboxFieldIDFromRefID(t *testing.T) {
+	id := New()
+
+	subId := InfoboxFieldIDFromRefID(&id)
+
+	assert.NotNil(t, subId)
+	assert.Equal(t, subId.id, id.id)
+}
+
+func TestInfoboxFieldID_ID(t *testing.T) {
+	id := New()
+	subId := InfoboxFieldIDFromRefID(&id)
+
+	idOrg := subId.ID()
+
+	assert.Equal(t, id, idOrg)
+}
+
+func TestInfoboxFieldID_String(t *testing.T) {
+	id := New()
+	subId := InfoboxFieldIDFromRefID(&id)
+
+	assert.Equal(t, subId.String(), id.String())
+}
+
+func TestInfoboxFieldID_GoString(t *testing.T) {
+	id := New()
+	subId := InfoboxFieldIDFromRefID(&id)
+
+	assert.Equal(t, subId.GoString(), "id.InfoboxFieldID("+id.String()+")")
+}
+
+func TestInfoboxFieldID_RefString(t *testing.T) {
+	id := New()
+	subId := InfoboxFieldIDFromRefID(&id)
+
+	refString := subId.StringRef()
+
+	assert.NotNil(t, refString)
+	assert.Equal(t, *refString, id.String())
+}
+
+func TestInfoboxFieldID_Ref(t *testing.T) {
+	id := New()
+	subId := InfoboxFieldIDFromRefID(&id)
+
+	subIdRef := subId.Ref()
+
+	assert.Equal(t, *subId, *subIdRef)
+}
+
+func TestInfoboxFieldID_CopyRef(t *testing.T) {
+	id := New()
+	subId := InfoboxFieldIDFromRefID(&id)
+
+	subIdCopyRef := subId.CopyRef()
+
+	assert.Equal(t, *subId, *subIdCopyRef)
+	assert.NotSame(t, subId, subIdCopyRef)
+}
+
+func TestInfoboxFieldID_IDRef(t *testing.T) {
+	id := New()
+	subId := InfoboxFieldIDFromRefID(&id)
+
+	assert.Equal(t, id, *subId.IDRef())
+}
+
+func TestInfoboxFieldID_StringRef(t *testing.T) {
+	id := New()
+	subId := InfoboxFieldIDFromRefID(&id)
+
+	assert.Equal(t, *subId.StringRef(), id.String())
+}
+
+func TestInfoboxFieldID_MarhsalJSON(t *testing.T) {
+	id := New()
+	subId := InfoboxFieldIDFromRefID(&id)
+
+	res, err := subId.MarhsalJSON()
+	exp, _ := json.Marshal(subId.String())
+
+	assert.Nil(t, err)
+	assert.Equal(t, exp, res)
+}
+
+func TestInfoboxFieldID_UnmarhsalJSON(t *testing.T) {
+	jsonString := "\"01f3zhkysvcxsnzepyyqtq21fb\""
+
+	subId := &InfoboxFieldID{}
+
+	err := subId.UnmarhsalJSON([]byte(jsonString))
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhkysvcxsnzepyyqtq21fb", subId.String())
+}
+
+func TestInfoboxFieldID_MarshalText(t *testing.T) {
+	id := New()
+	subId := InfoboxFieldIDFromRefID(&id)
+
+	res, err := subId.MarshalText()
+
+	assert.Nil(t, err)
+	assert.Equal(t, []byte(id.String()), res)
+}
+
+func TestInfoboxFieldID_UnmarshalText(t *testing.T) {
+	text := []byte("01f3zhcaq35403zdjnd6dcm0t2")
+
+	subId := &InfoboxFieldID{}
+
+	err := subId.UnmarshalText(text)
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhcaq35403zdjnd6dcm0t2", subId.String())
+
+}
+
+func TestInfoboxFieldID_IsNil(t *testing.T) {
+	subId := InfoboxFieldID{}
+
+	assert.True(t, subId.IsNil())
+
+	id := New()
+	subId = *InfoboxFieldIDFromRefID(&id)
+
+	assert.False(t, subId.IsNil())
+}
+
+func TestInfoboxFieldIDToKeys(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []InfoboxFieldID
+		expected []string
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]InfoboxFieldID, 0),
+			expected: make([]string, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []InfoboxFieldID{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+		},
+		{
+			name: "multiple elements",
+			input: []InfoboxFieldID{
+				MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, InfoboxFieldIDToKeys(tc.input))
+		})
+	}
+
+}
+
+func TestInfoboxFieldIDsFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []string
+		expected struct {
+			res []InfoboxFieldID
+			err error
+		}
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]string, 0),
+			expected: struct {
+				res []InfoboxFieldID
+				err error
+			}{
+				res: make([]InfoboxFieldID, 0),
+				err: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+			expected: struct {
+				res []InfoboxFieldID
+				err error
+			}{
+				res: []InfoboxFieldID{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2")},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []InfoboxFieldID
+				err error
+			}{
+				res: []InfoboxFieldID{
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []InfoboxFieldID
+				err error
+			}{
+				res: nil,
+				err: ErrInvalidID,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.expected.err != nil {
+				_, err := InfoboxFieldIDsFrom(tc.input)
+				assert.True(tt, errors.As(ErrInvalidID, &err))
+			} else {
+				res, err := InfoboxFieldIDsFrom(tc.input)
+				assert.Equal(tt, tc.expected.res, res)
+				assert.Nil(tt, err)
+			}
+
+		})
+	}
+}
+
+func TestInfoboxFieldIDsFromID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []ID
+		expected []InfoboxFieldID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]ID, 0),
+			expected: make([]InfoboxFieldID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []InfoboxFieldID{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []InfoboxFieldID{
+				MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := InfoboxFieldIDsFromID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestInfoboxFieldIDsFromIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+
+	testCases := []struct {
+		name     string
+		input    []*ID
+		expected []InfoboxFieldID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*ID, 0),
+			expected: make([]InfoboxFieldID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*ID{&id1},
+			expected: []InfoboxFieldID{MustInfoboxFieldID(id1.String())},
+		},
+		{
+			name:  "multiple elements",
+			input: []*ID{&id1, &id2, &id3},
+			expected: []InfoboxFieldID{
+				MustInfoboxFieldID(id1.String()),
+				MustInfoboxFieldID(id2.String()),
+				MustInfoboxFieldID(id3.String()),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := InfoboxFieldIDsFromIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestInfoboxFieldIDsToID(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []InfoboxFieldID
+		expected []ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]InfoboxFieldID, 0),
+			expected: make([]ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []InfoboxFieldID{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []InfoboxFieldID{
+				MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := InfoboxFieldIDsToID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestInfoboxFieldIDsToIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	subId1 := MustInfoboxFieldID(id1.String())
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	subId2 := MustInfoboxFieldID(id2.String())
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+	subId3 := MustInfoboxFieldID(id3.String())
+
+	testCases := []struct {
+		name     string
+		input    []*InfoboxFieldID
+		expected []*ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*InfoboxFieldID, 0),
+			expected: make([]*ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*InfoboxFieldID{&subId1},
+			expected: []*ID{&id1},
+		},
+		{
+			name:     "multiple elements",
+			input:    []*InfoboxFieldID{&subId1, &subId2, &subId3},
+			expected: []*ID{&id1, &id2, &id3},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := InfoboxFieldIDsToIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestNewInfoboxFieldIDSet(t *testing.T) {
+	InfoboxFieldIdSet := NewInfoboxFieldIDSet()
+
+	assert.NotNil(t, InfoboxFieldIdSet)
+	assert.Empty(t, InfoboxFieldIdSet.m)
+	assert.Empty(t, InfoboxFieldIdSet.s)
+}
+
+func TestInfoboxFieldIDSet_Add(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []InfoboxFieldID
+		expected *InfoboxFieldIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]InfoboxFieldID, 0),
+			expected: &InfoboxFieldIDSet{
+				m: map[InfoboxFieldID]struct{}{},
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []InfoboxFieldID{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: &InfoboxFieldIDSet{
+				m: map[InfoboxFieldID]struct{}{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []InfoboxFieldID{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []InfoboxFieldID{
+				MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &InfoboxFieldIDSet{
+				m: map[InfoboxFieldID]struct{}{
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []InfoboxFieldID{
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+		{
+			name: "multiple elements with duplication",
+			input: []InfoboxFieldID{
+				MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &InfoboxFieldIDSet{
+				m: map[InfoboxFieldID]struct{}{
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []InfoboxFieldID{
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewInfoboxFieldIDSet()
+			set.Add(tc.input...)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestInfoboxFieldIDSet_AddRef(t *testing.T) {
+	t.Parallel()
+
+	InfoboxFieldId := MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1")
+
+	testCases := []struct {
+		name     string
+		input    *InfoboxFieldID
+		expected *InfoboxFieldIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: nil,
+			expected: &InfoboxFieldIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: &InfoboxFieldId,
+			expected: &InfoboxFieldIDSet{
+				m: map[InfoboxFieldID]struct{}{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []InfoboxFieldID{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewInfoboxFieldIDSet()
+			set.AddRef(tc.input)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestInfoboxFieldIDSet_Has(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			InfoboxFieldIDSet
+			InfoboxFieldID
+		}
+		expected bool
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				InfoboxFieldIDSet
+				InfoboxFieldID
+			}{InfoboxFieldIDSet: InfoboxFieldIDSet{}, InfoboxFieldID: MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: false,
+		},
+		{
+			name: "Set Contains the element",
+			input: struct {
+				InfoboxFieldIDSet
+				InfoboxFieldID
+			}{InfoboxFieldIDSet: InfoboxFieldIDSet{
+				m: map[InfoboxFieldID]struct{}{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []InfoboxFieldID{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, InfoboxFieldID: MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: true,
+		},
+		{
+			name: "Set does not Contains the element",
+			input: struct {
+				InfoboxFieldIDSet
+				InfoboxFieldID
+			}{InfoboxFieldIDSet: InfoboxFieldIDSet{
+				m: map[InfoboxFieldID]struct{}{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []InfoboxFieldID{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, InfoboxFieldID: MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, tc.input.InfoboxFieldIDSet.Has(tc.input.InfoboxFieldID))
+		})
+	}
+}
+
+func TestInfoboxFieldIDSet_Clear(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    InfoboxFieldIDSet
+		expected InfoboxFieldIDSet
+	}{
+		{
+			name:  "Empty Set",
+			input: InfoboxFieldIDSet{},
+			expected: InfoboxFieldIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name: "Set Contains the element",
+			input: InfoboxFieldIDSet{
+				m: map[InfoboxFieldID]struct{}{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []InfoboxFieldID{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: InfoboxFieldIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			set := tc.input
+			p := &set
+			p.Clear()
+			assert.Equal(tt, tc.expected, *p)
+		})
+	}
+}
+
+func TestInfoboxFieldIDSet_All(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *InfoboxFieldIDSet
+		expected []InfoboxFieldID
+	}{
+		{
+			name: "Empty slice",
+			input: &InfoboxFieldIDSet{
+				m: map[InfoboxFieldID]struct{}{},
+				s: nil,
+			},
+			expected: make([]InfoboxFieldID, 0),
+		},
+		{
+			name: "1 element",
+			input: &InfoboxFieldIDSet{
+				m: map[InfoboxFieldID]struct{}{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []InfoboxFieldID{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: []InfoboxFieldID{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+		},
+		{
+			name: "multiple elements",
+			input: &InfoboxFieldIDSet{
+				m: map[InfoboxFieldID]struct{}{
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []InfoboxFieldID{
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: []InfoboxFieldID{
+				MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.All())
+		})
+	}
+}
+
+func TestInfoboxFieldIDSet_Clone(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *InfoboxFieldIDSet
+		expected *InfoboxFieldIDSet
+	}{
+		{
+			name:     "nil set",
+			input:    nil,
+			expected: NewInfoboxFieldIDSet(),
+		},
+		{
+			name:     "Empty set",
+			input:    NewInfoboxFieldIDSet(),
+			expected: NewInfoboxFieldIDSet(),
+		},
+		{
+			name: "1 element",
+			input: &InfoboxFieldIDSet{
+				m: map[InfoboxFieldID]struct{}{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []InfoboxFieldID{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: &InfoboxFieldIDSet{
+				m: map[InfoboxFieldID]struct{}{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []InfoboxFieldID{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: &InfoboxFieldIDSet{
+				m: map[InfoboxFieldID]struct{}{
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []InfoboxFieldID{
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: &InfoboxFieldIDSet{
+				m: map[InfoboxFieldID]struct{}{
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []InfoboxFieldID{
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			clone := tc.input.Clone()
+			assert.Equal(tt, tc.expected, clone)
+			assert.False(tt, tc.input == clone)
+		})
+	}
+}
+
+func TestInfoboxFieldIDSet_Merge(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			a *InfoboxFieldIDSet
+			b *InfoboxFieldIDSet
+		}
+		expected *InfoboxFieldIDSet
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				a *InfoboxFieldIDSet
+				b *InfoboxFieldIDSet
+			}{
+				a: &InfoboxFieldIDSet{},
+				b: &InfoboxFieldIDSet{},
+			},
+			expected: &InfoboxFieldIDSet{},
+		},
+		{
+			name: "1 Empty Set",
+			input: struct {
+				a *InfoboxFieldIDSet
+				b *InfoboxFieldIDSet
+			}{
+				a: &InfoboxFieldIDSet{
+					m: map[InfoboxFieldID]struct{}{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []InfoboxFieldID{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &InfoboxFieldIDSet{},
+			},
+			expected: &InfoboxFieldIDSet{
+				m: map[InfoboxFieldID]struct{}{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []InfoboxFieldID{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "2 non Empty Set",
+			input: struct {
+				a *InfoboxFieldIDSet
+				b *InfoboxFieldIDSet
+			}{
+				a: &InfoboxFieldIDSet{
+					m: map[InfoboxFieldID]struct{}{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []InfoboxFieldID{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &InfoboxFieldIDSet{
+					m: map[InfoboxFieldID]struct{}{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{}},
+					s: []InfoboxFieldID{MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2")},
+				},
+			},
+			expected: &InfoboxFieldIDSet{
+				m: map[InfoboxFieldID]struct{}{
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+				},
+				s: []InfoboxFieldID{
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustInfoboxFieldID("01f3zhcaq35403zdjnd6dcm0t2"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.a.Merge(tc.input.b))
+		})
+	}
+}
diff --git a/pkg/id/layer_gen_test.go b/pkg/id/layer_gen_test.go
new file mode 100644
index 00000000..a22ad38d
--- /dev/null
+++ b/pkg/id/layer_gen_test.go
@@ -0,0 +1,1004 @@
+// Code generated by gen, DO NOT EDIT.
+
+package id
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/oklog/ulid"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewLayerID(t *testing.T) {
+	id := NewLayerID()
+	assert.NotNil(t, id)
+	ulID, err := ulid.Parse(id.String())
+
+	assert.NotNil(t, ulID)
+	assert.Nil(t, err)
+}
+
+func TestLayerIDFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			result LayerID
+			err    error
+		}
+	}{
+		{
+			name:  "Fail:Not valid string",
+			input: "testMustFail",
+			expected: struct {
+				result LayerID
+				err    error
+			}{
+				LayerID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "Fail:Not valid string",
+			input: "",
+			expected: struct {
+				result LayerID
+				err    error
+			}{
+				LayerID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "success:valid string",
+			input: "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: struct {
+				result LayerID
+				err    error
+			}{
+				LayerID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+				nil,
+			},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result, err := LayerIDFrom(tc.input)
+			assert.Equal(tt, tc.expected.result, result)
+			if err != nil {
+				assert.True(tt, errors.As(tc.expected.err, &err))
+			}
+		})
+	}
+}
+
+func TestMustLayerID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name        string
+		input       string
+		shouldPanic bool
+		expected    LayerID
+	}{
+		{
+			name:        "Fail:Not valid string",
+			input:       "testMustFail",
+			shouldPanic: true,
+		},
+		{
+			name:        "Fail:Not valid string",
+			input:       "",
+			shouldPanic: true,
+		},
+		{
+			name:        "success:valid string",
+			input:       "01f2r7kg1fvvffp0gmexgy5hxy",
+			shouldPanic: false,
+			expected:    LayerID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.shouldPanic {
+				assert.Panics(tt, func() { MustBeID(tc.input) })
+				return
+			}
+			result := MustLayerID(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
+
+func TestLayerIDFromRef(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected *LayerID
+	}{
+		{
+			name:     "Fail:Not valid string",
+			input:    "testMustFail",
+			expected: nil,
+		},
+		{
+			name:     "Fail:Not valid string",
+			input:    "",
+			expected: nil,
+		},
+		{
+			name:     "success:valid string",
+			input:    "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: &LayerID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := LayerIDFromRef(&tc.input)
+			assert.Equal(tt, tc.expected, result)
+			if tc.expected != nil {
+				assert.Equal(tt, *tc.expected, *result)
+			}
+		})
+	}
+}
+
+func TestLayerIDFromRefID(t *testing.T) {
+	id := New()
+
+	subId := LayerIDFromRefID(&id)
+
+	assert.NotNil(t, subId)
+	assert.Equal(t, subId.id, id.id)
+}
+
+func TestLayerID_ID(t *testing.T) {
+	id := New()
+	subId := LayerIDFromRefID(&id)
+
+	idOrg := subId.ID()
+
+	assert.Equal(t, id, idOrg)
+}
+
+func TestLayerID_String(t *testing.T) {
+	id := New()
+	subId := LayerIDFromRefID(&id)
+
+	assert.Equal(t, subId.String(), id.String())
+}
+
+func TestLayerID_GoString(t *testing.T) {
+	id := New()
+	subId := LayerIDFromRefID(&id)
+
+	assert.Equal(t, subId.GoString(), "id.LayerID("+id.String()+")")
+}
+
+func TestLayerID_RefString(t *testing.T) {
+	id := New()
+	subId := LayerIDFromRefID(&id)
+
+	refString := subId.StringRef()
+
+	assert.NotNil(t, refString)
+	assert.Equal(t, *refString, id.String())
+}
+
+func TestLayerID_Ref(t *testing.T) {
+	id := New()
+	subId := LayerIDFromRefID(&id)
+
+	subIdRef := subId.Ref()
+
+	assert.Equal(t, *subId, *subIdRef)
+}
+
+func TestLayerID_CopyRef(t *testing.T) {
+	id := New()
+	subId := LayerIDFromRefID(&id)
+
+	subIdCopyRef := subId.CopyRef()
+
+	assert.Equal(t, *subId, *subIdCopyRef)
+	assert.NotSame(t, subId, subIdCopyRef)
+}
+
+func TestLayerID_IDRef(t *testing.T) {
+	id := New()
+	subId := LayerIDFromRefID(&id)
+
+	assert.Equal(t, id, *subId.IDRef())
+}
+
+func TestLayerID_StringRef(t *testing.T) {
+	id := New()
+	subId := LayerIDFromRefID(&id)
+
+	assert.Equal(t, *subId.StringRef(), id.String())
+}
+
+func TestLayerID_MarhsalJSON(t *testing.T) {
+	id := New()
+	subId := LayerIDFromRefID(&id)
+
+	res, err := subId.MarhsalJSON()
+	exp, _ := json.Marshal(subId.String())
+
+	assert.Nil(t, err)
+	assert.Equal(t, exp, res)
+}
+
+func TestLayerID_UnmarhsalJSON(t *testing.T) {
+	jsonString := "\"01f3zhkysvcxsnzepyyqtq21fb\""
+
+	subId := &LayerID{}
+
+	err := subId.UnmarhsalJSON([]byte(jsonString))
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhkysvcxsnzepyyqtq21fb", subId.String())
+}
+
+func TestLayerID_MarshalText(t *testing.T) {
+	id := New()
+	subId := LayerIDFromRefID(&id)
+
+	res, err := subId.MarshalText()
+
+	assert.Nil(t, err)
+	assert.Equal(t, []byte(id.String()), res)
+}
+
+func TestLayerID_UnmarshalText(t *testing.T) {
+	text := []byte("01f3zhcaq35403zdjnd6dcm0t2")
+
+	subId := &LayerID{}
+
+	err := subId.UnmarshalText(text)
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhcaq35403zdjnd6dcm0t2", subId.String())
+
+}
+
+func TestLayerID_IsNil(t *testing.T) {
+	subId := LayerID{}
+
+	assert.True(t, subId.IsNil())
+
+	id := New()
+	subId = *LayerIDFromRefID(&id)
+
+	assert.False(t, subId.IsNil())
+}
+
+func TestLayerIDToKeys(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []LayerID
+		expected []string
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]LayerID, 0),
+			expected: make([]string, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []LayerID{MustLayerID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+		},
+		{
+			name: "multiple elements",
+			input: []LayerID{
+				MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustLayerID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustLayerID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, LayerIDToKeys(tc.input))
+		})
+	}
+
+}
+
+func TestLayerIDsFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []string
+		expected struct {
+			res []LayerID
+			err error
+		}
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]string, 0),
+			expected: struct {
+				res []LayerID
+				err error
+			}{
+				res: make([]LayerID, 0),
+				err: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+			expected: struct {
+				res []LayerID
+				err error
+			}{
+				res: []LayerID{MustLayerID("01f3zhcaq35403zdjnd6dcm0t2")},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []LayerID
+				err error
+			}{
+				res: []LayerID{
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []LayerID
+				err error
+			}{
+				res: nil,
+				err: ErrInvalidID,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.expected.err != nil {
+				_, err := LayerIDsFrom(tc.input)
+				assert.True(tt, errors.As(ErrInvalidID, &err))
+			} else {
+				res, err := LayerIDsFrom(tc.input)
+				assert.Equal(tt, tc.expected.res, res)
+				assert.Nil(tt, err)
+			}
+
+		})
+	}
+}
+
+func TestLayerIDsFromID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []ID
+		expected []LayerID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]ID, 0),
+			expected: make([]LayerID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []LayerID{MustLayerID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []LayerID{
+				MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustLayerID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustLayerID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := LayerIDsFromID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestLayerIDsFromIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+
+	testCases := []struct {
+		name     string
+		input    []*ID
+		expected []LayerID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*ID, 0),
+			expected: make([]LayerID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*ID{&id1},
+			expected: []LayerID{MustLayerID(id1.String())},
+		},
+		{
+			name:  "multiple elements",
+			input: []*ID{&id1, &id2, &id3},
+			expected: []LayerID{
+				MustLayerID(id1.String()),
+				MustLayerID(id2.String()),
+				MustLayerID(id3.String()),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := LayerIDsFromIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestLayerIDsToID(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []LayerID
+		expected []ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]LayerID, 0),
+			expected: make([]ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []LayerID{MustLayerID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []LayerID{
+				MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustLayerID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustLayerID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := LayerIDsToID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestLayerIDsToIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	subId1 := MustLayerID(id1.String())
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	subId2 := MustLayerID(id2.String())
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+	subId3 := MustLayerID(id3.String())
+
+	testCases := []struct {
+		name     string
+		input    []*LayerID
+		expected []*ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*LayerID, 0),
+			expected: make([]*ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*LayerID{&subId1},
+			expected: []*ID{&id1},
+		},
+		{
+			name:     "multiple elements",
+			input:    []*LayerID{&subId1, &subId2, &subId3},
+			expected: []*ID{&id1, &id2, &id3},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := LayerIDsToIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestNewLayerIDSet(t *testing.T) {
+	LayerIdSet := NewLayerIDSet()
+
+	assert.NotNil(t, LayerIdSet)
+	assert.Empty(t, LayerIdSet.m)
+	assert.Empty(t, LayerIdSet.s)
+}
+
+func TestLayerIDSet_Add(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []LayerID
+		expected *LayerIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]LayerID, 0),
+			expected: &LayerIDSet{
+				m: map[LayerID]struct{}{},
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []LayerID{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: &LayerIDSet{
+				m: map[LayerID]struct{}{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []LayerID{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []LayerID{
+				MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustLayerID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustLayerID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &LayerIDSet{
+				m: map[LayerID]struct{}{
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []LayerID{
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+		{
+			name: "multiple elements with duplication",
+			input: []LayerID{
+				MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustLayerID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &LayerIDSet{
+				m: map[LayerID]struct{}{
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []LayerID{
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewLayerIDSet()
+			set.Add(tc.input...)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestLayerIDSet_AddRef(t *testing.T) {
+	t.Parallel()
+
+	LayerId := MustLayerID("01f3zhcaq35403zdjnd6dcm0t1")
+
+	testCases := []struct {
+		name     string
+		input    *LayerID
+		expected *LayerIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: nil,
+			expected: &LayerIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: &LayerId,
+			expected: &LayerIDSet{
+				m: map[LayerID]struct{}{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []LayerID{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewLayerIDSet()
+			set.AddRef(tc.input)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestLayerIDSet_Has(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			LayerIDSet
+			LayerID
+		}
+		expected bool
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				LayerIDSet
+				LayerID
+			}{LayerIDSet: LayerIDSet{}, LayerID: MustLayerID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: false,
+		},
+		{
+			name: "Set Contains the element",
+			input: struct {
+				LayerIDSet
+				LayerID
+			}{LayerIDSet: LayerIDSet{
+				m: map[LayerID]struct{}{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []LayerID{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, LayerID: MustLayerID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: true,
+		},
+		{
+			name: "Set does not Contains the element",
+			input: struct {
+				LayerIDSet
+				LayerID
+			}{LayerIDSet: LayerIDSet{
+				m: map[LayerID]struct{}{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []LayerID{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, LayerID: MustLayerID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, tc.input.LayerIDSet.Has(tc.input.LayerID))
+		})
+	}
+}
+
+func TestLayerIDSet_Clear(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    LayerIDSet
+		expected LayerIDSet
+	}{
+		{
+			name:  "Empty Set",
+			input: LayerIDSet{},
+			expected: LayerIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name: "Set Contains the element",
+			input: LayerIDSet{
+				m: map[LayerID]struct{}{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []LayerID{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: LayerIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			set := tc.input
+			p := &set
+			p.Clear()
+			assert.Equal(tt, tc.expected, *p)
+		})
+	}
+}
+
+func TestLayerIDSet_All(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *LayerIDSet
+		expected []LayerID
+	}{
+		{
+			name: "Empty slice",
+			input: &LayerIDSet{
+				m: map[LayerID]struct{}{},
+				s: nil,
+			},
+			expected: make([]LayerID, 0),
+		},
+		{
+			name: "1 element",
+			input: &LayerIDSet{
+				m: map[LayerID]struct{}{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []LayerID{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: []LayerID{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1")},
+		},
+		{
+			name: "multiple elements",
+			input: &LayerIDSet{
+				m: map[LayerID]struct{}{
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []LayerID{
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: []LayerID{
+				MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustLayerID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustLayerID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.All())
+		})
+	}
+}
+
+func TestLayerIDSet_Clone(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *LayerIDSet
+		expected *LayerIDSet
+	}{
+		{
+			name:     "nil set",
+			input:    nil,
+			expected: NewLayerIDSet(),
+		},
+		{
+			name:     "Empty set",
+			input:    NewLayerIDSet(),
+			expected: NewLayerIDSet(),
+		},
+		{
+			name: "1 element",
+			input: &LayerIDSet{
+				m: map[LayerID]struct{}{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []LayerID{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: &LayerIDSet{
+				m: map[LayerID]struct{}{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []LayerID{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: &LayerIDSet{
+				m: map[LayerID]struct{}{
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []LayerID{
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: &LayerIDSet{
+				m: map[LayerID]struct{}{
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []LayerID{
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			clone := tc.input.Clone()
+			assert.Equal(tt, tc.expected, clone)
+			assert.False(tt, tc.input == clone)
+		})
+	}
+}
+
+func TestLayerIDSet_Merge(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			a *LayerIDSet
+			b *LayerIDSet
+		}
+		expected *LayerIDSet
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				a *LayerIDSet
+				b *LayerIDSet
+			}{
+				a: &LayerIDSet{},
+				b: &LayerIDSet{},
+			},
+			expected: &LayerIDSet{},
+		},
+		{
+			name: "1 Empty Set",
+			input: struct {
+				a *LayerIDSet
+				b *LayerIDSet
+			}{
+				a: &LayerIDSet{
+					m: map[LayerID]struct{}{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []LayerID{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &LayerIDSet{},
+			},
+			expected: &LayerIDSet{
+				m: map[LayerID]struct{}{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []LayerID{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "2 non Empty Set",
+			input: struct {
+				a *LayerIDSet
+				b *LayerIDSet
+			}{
+				a: &LayerIDSet{
+					m: map[LayerID]struct{}{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []LayerID{MustLayerID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &LayerIDSet{
+					m: map[LayerID]struct{}{MustLayerID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{}},
+					s: []LayerID{MustLayerID("01f3zhcaq35403zdjnd6dcm0t2")},
+				},
+			},
+			expected: &LayerIDSet{
+				m: map[LayerID]struct{}{
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+				},
+				s: []LayerID{
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustLayerID("01f3zhcaq35403zdjnd6dcm0t2"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.a.Merge(tc.input.b))
+		})
+	}
+}
diff --git a/pkg/id/plugin_extension_test.go b/pkg/id/plugin_extension_test.go
new file mode 100644
index 00000000..02f95aac
--- /dev/null
+++ b/pkg/id/plugin_extension_test.go
@@ -0,0 +1,63 @@
+package id
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPluginExtensionIDFromRef(t *testing.T) {
+	t.Parallel()
+	input1 := "testStringId"
+	expected1 := PluginExtensionID(input1)
+	testCases := []struct {
+		name     string
+		input    *string
+		expected *PluginExtensionID
+	}{
+		{
+			name:     "success:string input",
+			input:    &input1,
+			expected: &expected1,
+		},
+		{
+			name:     "fail:nil pointer",
+			input:    nil,
+			expected: nil,
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := PluginExtensionIDFromRef(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
+
+func TestPluginExtensionID_Ref(t *testing.T) {
+	pluginExtensionID := PluginExtensionID("test")
+
+	assert.Equal(t, &pluginExtensionID, pluginExtensionID.Ref())
+}
+
+func TestPluginExtensionID_CopyRef(t *testing.T) {
+	pluginExtensionID := PluginExtensionID("test")
+
+	assert.Equal(t, pluginExtensionID, *pluginExtensionID.CopyRef())
+
+	assert.False(t, pluginExtensionID.Ref() == pluginExtensionID.CopyRef())
+}
+
+func TestPluginExtensionID_String(t *testing.T) {
+	pluginExtensionID := PluginExtensionID("test")
+
+	assert.Equal(t, "test", pluginExtensionID.String())
+}
+
+func TestPluginExtensionID_StringRef(t *testing.T) {
+	pluginExtensionID := PluginExtensionID("test")
+
+	assert.Equal(t, "test", *pluginExtensionID.StringRef())
+}
diff --git a/pkg/id/plugin_test.go b/pkg/id/plugin_test.go
index 8a3fca17..2691aefc 100644
--- a/pkg/id/plugin_test.go
+++ b/pkg/id/plugin_test.go
@@ -2,9 +2,11 @@ package id
 
 import (
 	"encoding"
+	"errors"
 	"strings"
 	"testing"
 
+	"github.com/blang/semver"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -12,13 +14,620 @@ var _ encoding.TextMarshaler = (*PluginID)(nil)
 var _ encoding.TextUnmarshaler = (*PluginID)(nil)
 
 func TestPluginIDValidator(t *testing.T) {
-	assert.True(t, validatePluginName("1cc.1_c-d"), "1cc.1_c-d")
-	assert.True(t, validatePluginName(strings.Repeat("a", 100)), "100 chars")
-	assert.False(t, validatePluginName(""), "empty")
-	assert.False(t, validatePluginName("  "), "space")
-	assert.False(t, validatePluginName("@bbb/aa-a_a"), "@bbb/aa-a_a")
-	assert.False(t, validatePluginName("bbb a"), "bbb a")
-	assert.False(t, validatePluginName("cccd="), "cccd=")
-	assert.False(t, validatePluginName("reearth"), "reearth")
-	assert.False(t, validatePluginName(strings.Repeat("a", 101)), "over 100 chars")
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected bool
+	}{
+		{
+			name:     "accepted name",
+			input:    "1cc.1_c-d",
+			expected: true,
+		},
+		{
+			name:     "les then 100",
+			input:    strings.Repeat("a", 100),
+			expected: true,
+		},
+		{
+			name:     "empty",
+			input:    "",
+			expected: false,
+		},
+		{
+			name:     "spaces",
+			input:    "    ",
+			expected: false,
+		},
+		{
+			name:     "contains not accepted characters",
+			input:    "@bbb/aa-a_a",
+			expected: false,
+		},
+		{
+			name:     "contain space",
+			input:    "bbb a",
+			expected: false,
+		},
+		{
+			name:     "contain =",
+			input:    "cccd=",
+			expected: false,
+		},
+		{
+			name:     "contains reearth reserved key word",
+			input:    "reearth",
+			expected: false,
+		},
+		{
+			name:     "more than 100 char",
+			input:    strings.Repeat("a", 101),
+			expected: false,
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, validatePluginName(tc.input))
+		})
+	}
+}
+
+func TestPluginIDFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			err    error
+			result PluginID
+		}
+	}{
+		{
+			name:  "success:accepted name",
+			input: "1cc.1_c-d#1.0.0",
+			expected: struct {
+				err    error
+				result PluginID
+			}{
+				err: nil,
+				result: PluginID{
+					name:    "1cc.1_c-d",
+					version: "1.0.0",
+					sys:     false,
+				},
+			},
+		},
+		{
+			name:  "success:official plugin id",
+			input: officialPluginIDStr,
+			expected: struct {
+				err    error
+				result PluginID
+			}{
+				err: nil,
+				result: PluginID{
+					name:    officialPluginIDStr,
+					version: "",
+					sys:     true,
+				},
+			},
+		},
+		{
+			name:  "fail:not valid name",
+			input: "1cc.1_c-d",
+			expected: struct {
+				err    error
+				result PluginID
+			}{
+				err:    ErrInvalidID,
+				result: PluginID{},
+			},
+		},
+		{
+			name:  "fail:not valid name",
+			input: "1cc.1_c-d/?s#1.0.0",
+			expected: struct {
+				err    error
+				result PluginID
+			}{
+				err:    ErrInvalidID,
+				result: PluginID{},
+			},
+		},
+		{
+			name:  "fail:not valid name",
+			input: "1cc.1_c-d/?s#1",
+			expected: struct {
+				err    error
+				result PluginID
+			}{
+				err:    ErrInvalidID,
+				result: PluginID{},
+			},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result, _ := PluginIDFrom(tc.input)
+			assert.Equal(tt, tc.expected.result, result)
+		})
+	}
+}
+
+func TestMustPluginID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			err    error
+			result PluginID
+		}
+	}{
+		{
+			name:  "success:accepted name",
+			input: "1cc.1_c-d#1.0.0",
+			expected: struct {
+				err    error
+				result PluginID
+			}{
+				err: nil,
+				result: PluginID{
+					name:    "1cc.1_c-d",
+					version: "1.0.0",
+					sys:     false,
+				},
+			},
+		},
+		{
+			name:  "fail:not valid name",
+			input: "1cc.1_c-d",
+			expected: struct {
+				err    error
+				result PluginID
+			}{
+				err:    ErrInvalidID,
+				result: PluginID{},
+			},
+		},
+		{
+			name:  "fail:not valid name",
+			input: "1cc.1_c-d/?s#1.0.0",
+			expected: struct {
+				err    error
+				result PluginID
+			}{
+				err:    ErrInvalidID,
+				result: PluginID{},
+			},
+		},
+		{
+			name:  "fail:not valid name",
+			input: "1cc.1_c-d/?s#1",
+			expected: struct {
+				err    error
+				result PluginID
+			}{
+				err:    ErrInvalidID,
+				result: PluginID{},
+			},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			if tc.expected.err != nil {
+				assert.Panics(tt, func() {
+					_ = MustPluginID(tc.input)
+				})
+			} else {
+				result := MustPluginID(tc.input)
+				assert.Equal(tt, tc.expected.result, result)
+			}
+		})
+	}
+}
+
+func TestPluginIDFromRef(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			err    error
+			result PluginID
+		}
+	}{
+		{
+			name:  "success:accepted name",
+			input: "1cc.1_c-d#1.0.0",
+			expected: struct {
+				err    error
+				result PluginID
+			}{
+				err: nil,
+				result: PluginID{
+					name:    "1cc.1_c-d",
+					version: "1.0.0",
+					sys:     false,
+				},
+			},
+		},
+		{
+			name:  "fail:not valid name",
+			input: "1cc.1_c-d",
+			expected: struct {
+				err    error
+				result PluginID
+			}{
+				err:    ErrInvalidID,
+				result: PluginID{},
+			},
+		},
+		{
+			name:  "fail:not valid name",
+			input: "1cc.1_c-d/?s#1.0.0",
+			expected: struct {
+				err    error
+				result PluginID
+			}{
+				err:    ErrInvalidID,
+				result: PluginID{},
+			},
+		},
+		{
+			name:  "fail:not valid name",
+			input: "1cc.1_c-d/?s#1",
+			expected: struct {
+				err    error
+				result PluginID
+			}{
+				err:    ErrInvalidID,
+				result: PluginID{},
+			},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			if tc.expected.err != nil {
+				result := PluginIDFromRef(&tc.input)
+				assert.Nil(tt, result)
+			} else {
+				result := PluginIDFromRef(&tc.input)
+				assert.Equal(tt, tc.expected.result, *result)
+			}
+		})
+	}
+}
+
+func TestPluginID_Name(t *testing.T) {
+	plugin := MustPluginID("MyPlugin#1.0.0")
+
+	assert.Equal(t, "MyPlugin", plugin.Name())
+}
+
+func TestPluginID_Version(t *testing.T) {
+	plugin := MustPluginID("MyPlugin#1.0.0")
+
+	assert.Equal(t, semver.MustParse("1.0.0"), plugin.Version())
+}
+
+func TestPluginID_System(t *testing.T) {
+	plugin := MustPluginID("MyPlugin#1.0.0")
+
+	assert.False(t, plugin.System())
+
+	plugin = MustPluginID(officialPluginIDStr)
+
+	assert.True(t, plugin.System())
+}
+
+func TestPluginID_Validate(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    PluginID
+		expected bool
+	}{
+		{
+			name: "success:accepted name",
+			input: PluginID{
+				name:    "1cc.1_c-d",
+				version: "1.0.0",
+				sys:     false,
+			},
+			expected: true,
+		},
+		{
+			name: "success:accepted name",
+			input: PluginID{
+				name:    "1cc.1/?_c-d",
+				version: "1.0.0",
+				sys:     false,
+			},
+			expected: false,
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			assert.Equal(tt, tc.expected, tc.input.Validate())
+		})
+	}
+}
+
+func TestPluginID_String(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    PluginID
+		expected string
+	}{
+		{
+			name: "success:accepted name",
+			input: PluginID{
+				name:    "ppl",
+				version: "1.0.0",
+				sys:     false,
+			},
+			expected: "ppl#1.0.0",
+		},
+		{
+			name: "success:accepted name",
+			input: PluginID{
+				name:    "plg",
+				version: "2.1.0-beta",
+				sys:     false,
+			},
+			expected: "plg#2.1.0-beta",
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			assert.Equal(tt, tc.expected, tc.input.String())
+		})
+	}
+}
+
+func TestPluginID_Ref(t *testing.T) {
+	pluginID := MustPluginID("Test#1.0.0")
+
+	ref := pluginID.Ref()
+
+	assert.Equal(t, *ref, pluginID)
+}
+
+func TestPluginID_CopyRef(t *testing.T) {
+	pluginID := MustPluginID("Test#1.0.0")
+
+	ref := pluginID.Ref()
+
+	ref2 := ref.CopyRef()
+
+	assert.Equal(t, *ref, pluginID)
+	assert.Equal(t, *ref2, pluginID)
+	assert.Equal(t, *ref, *ref2)
+}
+
+func TestPluginID_StringRef(t *testing.T) {
+	pluginID := MustPluginID("Test#1.0.0")
+
+	ref := pluginID.Ref()
+
+	strRef := ref.StringRef()
+
+	assert.Equal(t, pluginID.String(), *strRef)
+}
+
+func TestPluginID_Equal(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name  string
+		input struct {
+			pluginID1 PluginID
+			pluginID2 PluginID
+		}
+		expected bool
+	}{
+		{
+			name: "Equal",
+			input: struct {
+				pluginID1 PluginID
+				pluginID2 PluginID
+			}{
+				pluginID1: MustPluginID("Test#1.0.0"),
+				pluginID2: MustPluginID("Test#1.0.0"),
+			},
+			expected: true,
+		},
+		{
+			name: "Equal",
+			input: struct {
+				pluginID1 PluginID
+				pluginID2 PluginID
+			}{
+				pluginID1: MustPluginID("Test#1.0.0"),
+				pluginID2: MustPluginID("Test#1.0.1"),
+			},
+			expected: false,
+		},
+		{
+			name: "Equal",
+			input: struct {
+				pluginID1 PluginID
+				pluginID2 PluginID
+			}{
+				pluginID1: MustPluginID("Test0#1.0.0"),
+				pluginID2: MustPluginID("Test1#1.0.0"),
+			},
+			expected: false,
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, tc.input.pluginID1.Equal(tc.input.pluginID2))
+			assert.Equal(tt, tc.expected, tc.input.pluginID2.Equal(tc.input.pluginID1))
+		})
+	}
+
+}
+
+func TestPluginID_MarshalText(t *testing.T) {
+	pluginIdRef := MustPluginID("Test#1.0.0").Ref()
+
+	res, err := pluginIdRef.MarshalText()
+
+	assert.Nil(t, err)
+	assert.Equal(t, []byte("Test#1.0.0"), res)
+}
+
+func TestPluginID_UnmarshalText(t *testing.T) {
+	text := []byte("Test#1.0.0")
+
+	pluginId := &PluginID{}
+
+	err := pluginId.UnmarshalText(text)
+
+	assert.Nil(t, err)
+	assert.Equal(t, "Test#1.0.0", pluginId.String())
+
+}
+
+func TestPluginIDToKeys(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []PluginID
+		expected []string
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]PluginID, 0),
+			expected: make([]string, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []PluginID{MustPluginID("Test#1.0.0")},
+			expected: []string{"Test#1.0.0"},
+		},
+		{
+			name: "multiple elements",
+			input: []PluginID{
+				MustPluginID("Test#1.0.0"),
+				MustPluginID("Test#1.0.1"),
+				MustPluginID("Test#1.0.2"),
+			},
+			expected: []string{
+				"Test#1.0.0",
+				"Test#1.0.1",
+				"Test#1.0.2",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, PluginIDToKeys(tc.input))
+		})
+	}
+
+}
+
+func TestPluginIDsFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []string
+		expected struct {
+			res []PluginID
+			err error
+		}
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]string, 0),
+			expected: struct {
+				res []PluginID
+				err error
+			}{
+				res: make([]PluginID, 0),
+				err: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []string{"Test#1.0.0"},
+			expected: struct {
+				res []PluginID
+				err error
+			}{
+				res: []PluginID{MustPluginID("Test#1.0.0")},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"Test#1.0.0",
+				"Test#1.0.1",
+				"Test#1.0.2",
+			},
+			expected: struct {
+				res []PluginID
+				err error
+			}{
+				res: []PluginID{
+					MustPluginID("Test#1.0.0"),
+					MustPluginID("Test#1.0.1"),
+					MustPluginID("Test#1.0.2"),
+				},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"Test#1.0.0",
+				"Test#1.0.1",
+				"Test#1.0.2",
+			},
+			expected: struct {
+				res []PluginID
+				err error
+			}{
+				res: nil,
+				err: ErrInvalidID,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.expected.err != nil {
+				_, err := PluginIDsFrom(tc.input)
+				assert.True(tt, errors.As(ErrInvalidID, &err))
+			} else {
+				res, err := PluginIDsFrom(tc.input)
+				assert.Equal(tt, tc.expected.res, res)
+				assert.Nil(tt, err)
+			}
+
+		})
+	}
 }
diff --git a/pkg/id/project_gen_test.go b/pkg/id/project_gen_test.go
new file mode 100644
index 00000000..2a7a07fb
--- /dev/null
+++ b/pkg/id/project_gen_test.go
@@ -0,0 +1,1004 @@
+// Code generated by gen, DO NOT EDIT.
+
+package id
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/oklog/ulid"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewProjectID(t *testing.T) {
+	id := NewProjectID()
+	assert.NotNil(t, id)
+	ulID, err := ulid.Parse(id.String())
+
+	assert.NotNil(t, ulID)
+	assert.Nil(t, err)
+}
+
+func TestProjectIDFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			result ProjectID
+			err    error
+		}
+	}{
+		{
+			name:  "Fail:Not valid string",
+			input: "testMustFail",
+			expected: struct {
+				result ProjectID
+				err    error
+			}{
+				ProjectID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "Fail:Not valid string",
+			input: "",
+			expected: struct {
+				result ProjectID
+				err    error
+			}{
+				ProjectID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "success:valid string",
+			input: "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: struct {
+				result ProjectID
+				err    error
+			}{
+				ProjectID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+				nil,
+			},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result, err := ProjectIDFrom(tc.input)
+			assert.Equal(tt, tc.expected.result, result)
+			if err != nil {
+				assert.True(tt, errors.As(tc.expected.err, &err))
+			}
+		})
+	}
+}
+
+func TestMustProjectID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name        string
+		input       string
+		shouldPanic bool
+		expected    ProjectID
+	}{
+		{
+			name:        "Fail:Not valid string",
+			input:       "testMustFail",
+			shouldPanic: true,
+		},
+		{
+			name:        "Fail:Not valid string",
+			input:       "",
+			shouldPanic: true,
+		},
+		{
+			name:        "success:valid string",
+			input:       "01f2r7kg1fvvffp0gmexgy5hxy",
+			shouldPanic: false,
+			expected:    ProjectID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.shouldPanic {
+				assert.Panics(tt, func() { MustBeID(tc.input) })
+				return
+			}
+			result := MustProjectID(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
+
+func TestProjectIDFromRef(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected *ProjectID
+	}{
+		{
+			name:     "Fail:Not valid string",
+			input:    "testMustFail",
+			expected: nil,
+		},
+		{
+			name:     "Fail:Not valid string",
+			input:    "",
+			expected: nil,
+		},
+		{
+			name:     "success:valid string",
+			input:    "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: &ProjectID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := ProjectIDFromRef(&tc.input)
+			assert.Equal(tt, tc.expected, result)
+			if tc.expected != nil {
+				assert.Equal(tt, *tc.expected, *result)
+			}
+		})
+	}
+}
+
+func TestProjectIDFromRefID(t *testing.T) {
+	id := New()
+
+	subId := ProjectIDFromRefID(&id)
+
+	assert.NotNil(t, subId)
+	assert.Equal(t, subId.id, id.id)
+}
+
+func TestProjectID_ID(t *testing.T) {
+	id := New()
+	subId := ProjectIDFromRefID(&id)
+
+	idOrg := subId.ID()
+
+	assert.Equal(t, id, idOrg)
+}
+
+func TestProjectID_String(t *testing.T) {
+	id := New()
+	subId := ProjectIDFromRefID(&id)
+
+	assert.Equal(t, subId.String(), id.String())
+}
+
+func TestProjectID_GoString(t *testing.T) {
+	id := New()
+	subId := ProjectIDFromRefID(&id)
+
+	assert.Equal(t, subId.GoString(), "id.ProjectID("+id.String()+")")
+}
+
+func TestProjectID_RefString(t *testing.T) {
+	id := New()
+	subId := ProjectIDFromRefID(&id)
+
+	refString := subId.StringRef()
+
+	assert.NotNil(t, refString)
+	assert.Equal(t, *refString, id.String())
+}
+
+func TestProjectID_Ref(t *testing.T) {
+	id := New()
+	subId := ProjectIDFromRefID(&id)
+
+	subIdRef := subId.Ref()
+
+	assert.Equal(t, *subId, *subIdRef)
+}
+
+func TestProjectID_CopyRef(t *testing.T) {
+	id := New()
+	subId := ProjectIDFromRefID(&id)
+
+	subIdCopyRef := subId.CopyRef()
+
+	assert.Equal(t, *subId, *subIdCopyRef)
+	assert.NotSame(t, subId, subIdCopyRef)
+}
+
+func TestProjectID_IDRef(t *testing.T) {
+	id := New()
+	subId := ProjectIDFromRefID(&id)
+
+	assert.Equal(t, id, *subId.IDRef())
+}
+
+func TestProjectID_StringRef(t *testing.T) {
+	id := New()
+	subId := ProjectIDFromRefID(&id)
+
+	assert.Equal(t, *subId.StringRef(), id.String())
+}
+
+func TestProjectID_MarhsalJSON(t *testing.T) {
+	id := New()
+	subId := ProjectIDFromRefID(&id)
+
+	res, err := subId.MarhsalJSON()
+	exp, _ := json.Marshal(subId.String())
+
+	assert.Nil(t, err)
+	assert.Equal(t, exp, res)
+}
+
+func TestProjectID_UnmarhsalJSON(t *testing.T) {
+	jsonString := "\"01f3zhkysvcxsnzepyyqtq21fb\""
+
+	subId := &ProjectID{}
+
+	err := subId.UnmarhsalJSON([]byte(jsonString))
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhkysvcxsnzepyyqtq21fb", subId.String())
+}
+
+func TestProjectID_MarshalText(t *testing.T) {
+	id := New()
+	subId := ProjectIDFromRefID(&id)
+
+	res, err := subId.MarshalText()
+
+	assert.Nil(t, err)
+	assert.Equal(t, []byte(id.String()), res)
+}
+
+func TestProjectID_UnmarshalText(t *testing.T) {
+	text := []byte("01f3zhcaq35403zdjnd6dcm0t2")
+
+	subId := &ProjectID{}
+
+	err := subId.UnmarshalText(text)
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhcaq35403zdjnd6dcm0t2", subId.String())
+
+}
+
+func TestProjectID_IsNil(t *testing.T) {
+	subId := ProjectID{}
+
+	assert.True(t, subId.IsNil())
+
+	id := New()
+	subId = *ProjectIDFromRefID(&id)
+
+	assert.False(t, subId.IsNil())
+}
+
+func TestProjectIDToKeys(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []ProjectID
+		expected []string
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]ProjectID, 0),
+			expected: make([]string, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []ProjectID{MustProjectID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+		},
+		{
+			name: "multiple elements",
+			input: []ProjectID{
+				MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustProjectID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustProjectID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, ProjectIDToKeys(tc.input))
+		})
+	}
+
+}
+
+func TestProjectIDsFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []string
+		expected struct {
+			res []ProjectID
+			err error
+		}
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]string, 0),
+			expected: struct {
+				res []ProjectID
+				err error
+			}{
+				res: make([]ProjectID, 0),
+				err: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+			expected: struct {
+				res []ProjectID
+				err error
+			}{
+				res: []ProjectID{MustProjectID("01f3zhcaq35403zdjnd6dcm0t2")},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []ProjectID
+				err error
+			}{
+				res: []ProjectID{
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []ProjectID
+				err error
+			}{
+				res: nil,
+				err: ErrInvalidID,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.expected.err != nil {
+				_, err := ProjectIDsFrom(tc.input)
+				assert.True(tt, errors.As(ErrInvalidID, &err))
+			} else {
+				res, err := ProjectIDsFrom(tc.input)
+				assert.Equal(tt, tc.expected.res, res)
+				assert.Nil(tt, err)
+			}
+
+		})
+	}
+}
+
+func TestProjectIDsFromID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []ID
+		expected []ProjectID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]ID, 0),
+			expected: make([]ProjectID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []ProjectID{MustProjectID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []ProjectID{
+				MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustProjectID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustProjectID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := ProjectIDsFromID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestProjectIDsFromIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+
+	testCases := []struct {
+		name     string
+		input    []*ID
+		expected []ProjectID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*ID, 0),
+			expected: make([]ProjectID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*ID{&id1},
+			expected: []ProjectID{MustProjectID(id1.String())},
+		},
+		{
+			name:  "multiple elements",
+			input: []*ID{&id1, &id2, &id3},
+			expected: []ProjectID{
+				MustProjectID(id1.String()),
+				MustProjectID(id2.String()),
+				MustProjectID(id3.String()),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := ProjectIDsFromIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestProjectIDsToID(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []ProjectID
+		expected []ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]ProjectID, 0),
+			expected: make([]ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []ProjectID{MustProjectID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []ProjectID{
+				MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustProjectID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustProjectID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := ProjectIDsToID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestProjectIDsToIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	subId1 := MustProjectID(id1.String())
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	subId2 := MustProjectID(id2.String())
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+	subId3 := MustProjectID(id3.String())
+
+	testCases := []struct {
+		name     string
+		input    []*ProjectID
+		expected []*ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*ProjectID, 0),
+			expected: make([]*ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*ProjectID{&subId1},
+			expected: []*ID{&id1},
+		},
+		{
+			name:     "multiple elements",
+			input:    []*ProjectID{&subId1, &subId2, &subId3},
+			expected: []*ID{&id1, &id2, &id3},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := ProjectIDsToIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestNewProjectIDSet(t *testing.T) {
+	ProjectIdSet := NewProjectIDSet()
+
+	assert.NotNil(t, ProjectIdSet)
+	assert.Empty(t, ProjectIdSet.m)
+	assert.Empty(t, ProjectIdSet.s)
+}
+
+func TestProjectIDSet_Add(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []ProjectID
+		expected *ProjectIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]ProjectID, 0),
+			expected: &ProjectIDSet{
+				m: map[ProjectID]struct{}{},
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []ProjectID{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: &ProjectIDSet{
+				m: map[ProjectID]struct{}{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []ProjectID{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []ProjectID{
+				MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustProjectID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustProjectID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &ProjectIDSet{
+				m: map[ProjectID]struct{}{
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []ProjectID{
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+		{
+			name: "multiple elements with duplication",
+			input: []ProjectID{
+				MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustProjectID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &ProjectIDSet{
+				m: map[ProjectID]struct{}{
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []ProjectID{
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewProjectIDSet()
+			set.Add(tc.input...)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestProjectIDSet_AddRef(t *testing.T) {
+	t.Parallel()
+
+	ProjectId := MustProjectID("01f3zhcaq35403zdjnd6dcm0t1")
+
+	testCases := []struct {
+		name     string
+		input    *ProjectID
+		expected *ProjectIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: nil,
+			expected: &ProjectIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: &ProjectId,
+			expected: &ProjectIDSet{
+				m: map[ProjectID]struct{}{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []ProjectID{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewProjectIDSet()
+			set.AddRef(tc.input)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestProjectIDSet_Has(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			ProjectIDSet
+			ProjectID
+		}
+		expected bool
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				ProjectIDSet
+				ProjectID
+			}{ProjectIDSet: ProjectIDSet{}, ProjectID: MustProjectID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: false,
+		},
+		{
+			name: "Set Contains the element",
+			input: struct {
+				ProjectIDSet
+				ProjectID
+			}{ProjectIDSet: ProjectIDSet{
+				m: map[ProjectID]struct{}{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []ProjectID{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, ProjectID: MustProjectID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: true,
+		},
+		{
+			name: "Set does not Contains the element",
+			input: struct {
+				ProjectIDSet
+				ProjectID
+			}{ProjectIDSet: ProjectIDSet{
+				m: map[ProjectID]struct{}{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []ProjectID{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, ProjectID: MustProjectID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, tc.input.ProjectIDSet.Has(tc.input.ProjectID))
+		})
+	}
+}
+
+func TestProjectIDSet_Clear(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    ProjectIDSet
+		expected ProjectIDSet
+	}{
+		{
+			name:  "Empty Set",
+			input: ProjectIDSet{},
+			expected: ProjectIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name: "Set Contains the element",
+			input: ProjectIDSet{
+				m: map[ProjectID]struct{}{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []ProjectID{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: ProjectIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			set := tc.input
+			p := &set
+			p.Clear()
+			assert.Equal(tt, tc.expected, *p)
+		})
+	}
+}
+
+func TestProjectIDSet_All(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *ProjectIDSet
+		expected []ProjectID
+	}{
+		{
+			name: "Empty slice",
+			input: &ProjectIDSet{
+				m: map[ProjectID]struct{}{},
+				s: nil,
+			},
+			expected: make([]ProjectID, 0),
+		},
+		{
+			name: "1 element",
+			input: &ProjectIDSet{
+				m: map[ProjectID]struct{}{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []ProjectID{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: []ProjectID{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1")},
+		},
+		{
+			name: "multiple elements",
+			input: &ProjectIDSet{
+				m: map[ProjectID]struct{}{
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []ProjectID{
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: []ProjectID{
+				MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustProjectID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustProjectID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.All())
+		})
+	}
+}
+
+func TestProjectIDSet_Clone(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *ProjectIDSet
+		expected *ProjectIDSet
+	}{
+		{
+			name:     "nil set",
+			input:    nil,
+			expected: NewProjectIDSet(),
+		},
+		{
+			name:     "Empty set",
+			input:    NewProjectIDSet(),
+			expected: NewProjectIDSet(),
+		},
+		{
+			name: "1 element",
+			input: &ProjectIDSet{
+				m: map[ProjectID]struct{}{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []ProjectID{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: &ProjectIDSet{
+				m: map[ProjectID]struct{}{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []ProjectID{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: &ProjectIDSet{
+				m: map[ProjectID]struct{}{
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []ProjectID{
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: &ProjectIDSet{
+				m: map[ProjectID]struct{}{
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []ProjectID{
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			clone := tc.input.Clone()
+			assert.Equal(tt, tc.expected, clone)
+			assert.False(tt, tc.input == clone)
+		})
+	}
+}
+
+func TestProjectIDSet_Merge(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			a *ProjectIDSet
+			b *ProjectIDSet
+		}
+		expected *ProjectIDSet
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				a *ProjectIDSet
+				b *ProjectIDSet
+			}{
+				a: &ProjectIDSet{},
+				b: &ProjectIDSet{},
+			},
+			expected: &ProjectIDSet{},
+		},
+		{
+			name: "1 Empty Set",
+			input: struct {
+				a *ProjectIDSet
+				b *ProjectIDSet
+			}{
+				a: &ProjectIDSet{
+					m: map[ProjectID]struct{}{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []ProjectID{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &ProjectIDSet{},
+			},
+			expected: &ProjectIDSet{
+				m: map[ProjectID]struct{}{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []ProjectID{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "2 non Empty Set",
+			input: struct {
+				a *ProjectIDSet
+				b *ProjectIDSet
+			}{
+				a: &ProjectIDSet{
+					m: map[ProjectID]struct{}{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []ProjectID{MustProjectID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &ProjectIDSet{
+					m: map[ProjectID]struct{}{MustProjectID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{}},
+					s: []ProjectID{MustProjectID("01f3zhcaq35403zdjnd6dcm0t2")},
+				},
+			},
+			expected: &ProjectIDSet{
+				m: map[ProjectID]struct{}{
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+				},
+				s: []ProjectID{
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustProjectID("01f3zhcaq35403zdjnd6dcm0t2"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.a.Merge(tc.input.b))
+		})
+	}
+}
diff --git a/pkg/id/property_gen_test.go b/pkg/id/property_gen_test.go
new file mode 100644
index 00000000..a3fa5bf0
--- /dev/null
+++ b/pkg/id/property_gen_test.go
@@ -0,0 +1,1004 @@
+// Code generated by gen, DO NOT EDIT.
+
+package id
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/oklog/ulid"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewPropertyID(t *testing.T) {
+	id := NewPropertyID()
+	assert.NotNil(t, id)
+	ulID, err := ulid.Parse(id.String())
+
+	assert.NotNil(t, ulID)
+	assert.Nil(t, err)
+}
+
+func TestPropertyIDFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			result PropertyID
+			err    error
+		}
+	}{
+		{
+			name:  "Fail:Not valid string",
+			input: "testMustFail",
+			expected: struct {
+				result PropertyID
+				err    error
+			}{
+				PropertyID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "Fail:Not valid string",
+			input: "",
+			expected: struct {
+				result PropertyID
+				err    error
+			}{
+				PropertyID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "success:valid string",
+			input: "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: struct {
+				result PropertyID
+				err    error
+			}{
+				PropertyID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+				nil,
+			},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result, err := PropertyIDFrom(tc.input)
+			assert.Equal(tt, tc.expected.result, result)
+			if err != nil {
+				assert.True(tt, errors.As(tc.expected.err, &err))
+			}
+		})
+	}
+}
+
+func TestMustPropertyID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name        string
+		input       string
+		shouldPanic bool
+		expected    PropertyID
+	}{
+		{
+			name:        "Fail:Not valid string",
+			input:       "testMustFail",
+			shouldPanic: true,
+		},
+		{
+			name:        "Fail:Not valid string",
+			input:       "",
+			shouldPanic: true,
+		},
+		{
+			name:        "success:valid string",
+			input:       "01f2r7kg1fvvffp0gmexgy5hxy",
+			shouldPanic: false,
+			expected:    PropertyID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.shouldPanic {
+				assert.Panics(tt, func() { MustBeID(tc.input) })
+				return
+			}
+			result := MustPropertyID(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
+
+func TestPropertyIDFromRef(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected *PropertyID
+	}{
+		{
+			name:     "Fail:Not valid string",
+			input:    "testMustFail",
+			expected: nil,
+		},
+		{
+			name:     "Fail:Not valid string",
+			input:    "",
+			expected: nil,
+		},
+		{
+			name:     "success:valid string",
+			input:    "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: &PropertyID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := PropertyIDFromRef(&tc.input)
+			assert.Equal(tt, tc.expected, result)
+			if tc.expected != nil {
+				assert.Equal(tt, *tc.expected, *result)
+			}
+		})
+	}
+}
+
+func TestPropertyIDFromRefID(t *testing.T) {
+	id := New()
+
+	subId := PropertyIDFromRefID(&id)
+
+	assert.NotNil(t, subId)
+	assert.Equal(t, subId.id, id.id)
+}
+
+func TestPropertyID_ID(t *testing.T) {
+	id := New()
+	subId := PropertyIDFromRefID(&id)
+
+	idOrg := subId.ID()
+
+	assert.Equal(t, id, idOrg)
+}
+
+func TestPropertyID_String(t *testing.T) {
+	id := New()
+	subId := PropertyIDFromRefID(&id)
+
+	assert.Equal(t, subId.String(), id.String())
+}
+
+func TestPropertyID_GoString(t *testing.T) {
+	id := New()
+	subId := PropertyIDFromRefID(&id)
+
+	assert.Equal(t, subId.GoString(), "id.PropertyID("+id.String()+")")
+}
+
+func TestPropertyID_RefString(t *testing.T) {
+	id := New()
+	subId := PropertyIDFromRefID(&id)
+
+	refString := subId.StringRef()
+
+	assert.NotNil(t, refString)
+	assert.Equal(t, *refString, id.String())
+}
+
+func TestPropertyID_Ref(t *testing.T) {
+	id := New()
+	subId := PropertyIDFromRefID(&id)
+
+	subIdRef := subId.Ref()
+
+	assert.Equal(t, *subId, *subIdRef)
+}
+
+func TestPropertyID_CopyRef(t *testing.T) {
+	id := New()
+	subId := PropertyIDFromRefID(&id)
+
+	subIdCopyRef := subId.CopyRef()
+
+	assert.Equal(t, *subId, *subIdCopyRef)
+	assert.False(t, subId == subIdCopyRef)
+}
+
+func TestPropertyID_IDRef(t *testing.T) {
+	id := New()
+	subId := PropertyIDFromRefID(&id)
+
+	assert.Equal(t, id, *subId.IDRef())
+}
+
+func TestPropertyID_StringRef(t *testing.T) {
+	id := New()
+	subId := PropertyIDFromRefID(&id)
+
+	assert.Equal(t, *subId.StringRef(), id.String())
+}
+
+func TestPropertyID_MarhsalJSON(t *testing.T) {
+	id := New()
+	subId := PropertyIDFromRefID(&id)
+
+	res, err := subId.MarhsalJSON()
+	exp, _ := json.Marshal(subId.String())
+
+	assert.Nil(t, err)
+	assert.Equal(t, exp, res)
+}
+
+func TestPropertyID_UnmarhsalJSON(t *testing.T) {
+	jsonString := "\"01f3zhkysvcxsnzepyyqtq21fb\""
+
+	subId := &PropertyID{}
+
+	err := subId.UnmarhsalJSON([]byte(jsonString))
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhkysvcxsnzepyyqtq21fb", subId.String())
+}
+
+func TestPropertyID_MarshalText(t *testing.T) {
+	id := New()
+	subId := PropertyIDFromRefID(&id)
+
+	res, err := subId.MarshalText()
+
+	assert.Nil(t, err)
+	assert.Equal(t, []byte(id.String()), res)
+}
+
+func TestPropertyID_UnmarshalText(t *testing.T) {
+	text := []byte("01f3zhcaq35403zdjnd6dcm0t2")
+
+	subId := &PropertyID{}
+
+	err := subId.UnmarshalText(text)
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhcaq35403zdjnd6dcm0t2", subId.String())
+
+}
+
+func TestPropertyID_IsNil(t *testing.T) {
+	subId := PropertyID{}
+
+	assert.True(t, subId.IsNil())
+
+	id := New()
+	subId = *PropertyIDFromRefID(&id)
+
+	assert.False(t, subId.IsNil())
+}
+
+func TestPropertyIDToKeys(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []PropertyID
+		expected []string
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]PropertyID, 0),
+			expected: make([]string, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []PropertyID{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+		},
+		{
+			name: "multiple elements",
+			input: []PropertyID{
+				MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustPropertyID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, PropertyIDToKeys(tc.input))
+		})
+	}
+
+}
+
+func TestPropertyIDsFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []string
+		expected struct {
+			res []PropertyID
+			err error
+		}
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]string, 0),
+			expected: struct {
+				res []PropertyID
+				err error
+			}{
+				res: make([]PropertyID, 0),
+				err: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+			expected: struct {
+				res []PropertyID
+				err error
+			}{
+				res: []PropertyID{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2")},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []PropertyID
+				err error
+			}{
+				res: []PropertyID{
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []PropertyID
+				err error
+			}{
+				res: nil,
+				err: ErrInvalidID,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.expected.err != nil {
+				_, err := PropertyIDsFrom(tc.input)
+				assert.True(tt, errors.As(ErrInvalidID, &err))
+			} else {
+				res, err := PropertyIDsFrom(tc.input)
+				assert.Equal(tt, tc.expected.res, res)
+				assert.Nil(tt, err)
+			}
+
+		})
+	}
+}
+
+func TestPropertyIDsFromID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []ID
+		expected []PropertyID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]ID, 0),
+			expected: make([]PropertyID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []PropertyID{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []PropertyID{
+				MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustPropertyID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := PropertyIDsFromID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestPropertyIDsFromIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+
+	testCases := []struct {
+		name     string
+		input    []*ID
+		expected []PropertyID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*ID, 0),
+			expected: make([]PropertyID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*ID{&id1},
+			expected: []PropertyID{MustPropertyID(id1.String())},
+		},
+		{
+			name:  "multiple elements",
+			input: []*ID{&id1, &id2, &id3},
+			expected: []PropertyID{
+				MustPropertyID(id1.String()),
+				MustPropertyID(id2.String()),
+				MustPropertyID(id3.String()),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := PropertyIDsFromIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestPropertyIDsToID(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []PropertyID
+		expected []ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]PropertyID, 0),
+			expected: make([]ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []PropertyID{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []PropertyID{
+				MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustPropertyID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := PropertyIDsToID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestPropertyIDsToIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	subId1 := MustPropertyID(id1.String())
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	subId2 := MustPropertyID(id2.String())
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+	subId3 := MustPropertyID(id3.String())
+
+	testCases := []struct {
+		name     string
+		input    []*PropertyID
+		expected []*ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*PropertyID, 0),
+			expected: make([]*ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*PropertyID{&subId1},
+			expected: []*ID{&id1},
+		},
+		{
+			name:     "multiple elements",
+			input:    []*PropertyID{&subId1, &subId2, &subId3},
+			expected: []*ID{&id1, &id2, &id3},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := PropertyIDsToIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestNewPropertyIDSet(t *testing.T) {
+	PropertyIdSet := NewPropertyIDSet()
+
+	assert.NotNil(t, PropertyIdSet)
+	assert.Empty(t, PropertyIdSet.m)
+	assert.Empty(t, PropertyIdSet.s)
+}
+
+func TestPropertyIDSet_Add(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []PropertyID
+		expected *PropertyIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]PropertyID, 0),
+			expected: &PropertyIDSet{
+				m: map[PropertyID]struct{}{},
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []PropertyID{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: &PropertyIDSet{
+				m: map[PropertyID]struct{}{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []PropertyID{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []PropertyID{
+				MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustPropertyID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &PropertyIDSet{
+				m: map[PropertyID]struct{}{
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []PropertyID{
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+		{
+			name: "multiple elements with duplication",
+			input: []PropertyID{
+				MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustPropertyID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &PropertyIDSet{
+				m: map[PropertyID]struct{}{
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []PropertyID{
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewPropertyIDSet()
+			set.Add(tc.input...)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestPropertyIDSet_AddRef(t *testing.T) {
+	t.Parallel()
+
+	PropertyId := MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1")
+
+	testCases := []struct {
+		name     string
+		input    *PropertyID
+		expected *PropertyIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: nil,
+			expected: &PropertyIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: &PropertyId,
+			expected: &PropertyIDSet{
+				m: map[PropertyID]struct{}{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []PropertyID{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewPropertyIDSet()
+			set.AddRef(tc.input)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestPropertyIDSet_Has(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			PropertyIDSet
+			PropertyID
+		}
+		expected bool
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				PropertyIDSet
+				PropertyID
+			}{PropertyIDSet: PropertyIDSet{}, PropertyID: MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: false,
+		},
+		{
+			name: "Set Contains the element",
+			input: struct {
+				PropertyIDSet
+				PropertyID
+			}{PropertyIDSet: PropertyIDSet{
+				m: map[PropertyID]struct{}{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []PropertyID{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, PropertyID: MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: true,
+		},
+		{
+			name: "Set does not Contains the element",
+			input: struct {
+				PropertyIDSet
+				PropertyID
+			}{PropertyIDSet: PropertyIDSet{
+				m: map[PropertyID]struct{}{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []PropertyID{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, PropertyID: MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, tc.input.PropertyIDSet.Has(tc.input.PropertyID))
+		})
+	}
+}
+
+func TestPropertyIDSet_Clear(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    PropertyIDSet
+		expected PropertyIDSet
+	}{
+		{
+			name:  "Empty Set",
+			input: PropertyIDSet{},
+			expected: PropertyIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name: "Set Contains the element",
+			input: PropertyIDSet{
+				m: map[PropertyID]struct{}{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []PropertyID{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: PropertyIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			set := tc.input
+			p := &set
+			p.Clear()
+			assert.Equal(tt, tc.expected, *p)
+		})
+	}
+}
+
+func TestPropertyIDSet_All(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *PropertyIDSet
+		expected []PropertyID
+	}{
+		{
+			name: "Empty slice",
+			input: &PropertyIDSet{
+				m: map[PropertyID]struct{}{},
+				s: nil,
+			},
+			expected: make([]PropertyID, 0),
+		},
+		{
+			name: "1 element",
+			input: &PropertyIDSet{
+				m: map[PropertyID]struct{}{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []PropertyID{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: []PropertyID{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1")},
+		},
+		{
+			name: "multiple elements",
+			input: &PropertyIDSet{
+				m: map[PropertyID]struct{}{
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []PropertyID{
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: []PropertyID{
+				MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustPropertyID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.All())
+		})
+	}
+}
+
+func TestPropertyIDSet_Clone(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *PropertyIDSet
+		expected *PropertyIDSet
+	}{
+		{
+			name:     "nil set",
+			input:    nil,
+			expected: NewPropertyIDSet(),
+		},
+		{
+			name:     "Empty set",
+			input:    NewPropertyIDSet(),
+			expected: NewPropertyIDSet(),
+		},
+		{
+			name: "1 element",
+			input: &PropertyIDSet{
+				m: map[PropertyID]struct{}{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []PropertyID{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: &PropertyIDSet{
+				m: map[PropertyID]struct{}{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []PropertyID{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: &PropertyIDSet{
+				m: map[PropertyID]struct{}{
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []PropertyID{
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: &PropertyIDSet{
+				m: map[PropertyID]struct{}{
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []PropertyID{
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			clone := tc.input.Clone()
+			assert.Equal(tt, tc.expected, clone)
+			assert.False(tt, tc.input == clone)
+		})
+	}
+}
+
+func TestPropertyIDSet_Merge(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			a *PropertyIDSet
+			b *PropertyIDSet
+		}
+		expected *PropertyIDSet
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				a *PropertyIDSet
+				b *PropertyIDSet
+			}{
+				a: &PropertyIDSet{},
+				b: &PropertyIDSet{},
+			},
+			expected: &PropertyIDSet{},
+		},
+		{
+			name: "1 Empty Set",
+			input: struct {
+				a *PropertyIDSet
+				b *PropertyIDSet
+			}{
+				a: &PropertyIDSet{
+					m: map[PropertyID]struct{}{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []PropertyID{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &PropertyIDSet{},
+			},
+			expected: &PropertyIDSet{
+				m: map[PropertyID]struct{}{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []PropertyID{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "2 non Empty Set",
+			input: struct {
+				a *PropertyIDSet
+				b *PropertyIDSet
+			}{
+				a: &PropertyIDSet{
+					m: map[PropertyID]struct{}{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []PropertyID{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &PropertyIDSet{
+					m: map[PropertyID]struct{}{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{}},
+					s: []PropertyID{MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2")},
+				},
+			},
+			expected: &PropertyIDSet{
+				m: map[PropertyID]struct{}{
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+				},
+				s: []PropertyID{
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustPropertyID("01f3zhcaq35403zdjnd6dcm0t2"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.a.Merge(tc.input.b))
+		})
+	}
+}
diff --git a/pkg/id/property_item_gen_test.go b/pkg/id/property_item_gen_test.go
new file mode 100644
index 00000000..96e0617e
--- /dev/null
+++ b/pkg/id/property_item_gen_test.go
@@ -0,0 +1,1004 @@
+// Code generated by gen, DO NOT EDIT.
+
+package id
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/oklog/ulid"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewPropertyItemID(t *testing.T) {
+	id := NewPropertyItemID()
+	assert.NotNil(t, id)
+	ulID, err := ulid.Parse(id.String())
+
+	assert.NotNil(t, ulID)
+	assert.Nil(t, err)
+}
+
+func TestPropertyItemIDFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			result PropertyItemID
+			err    error
+		}
+	}{
+		{
+			name:  "Fail:Not valid string",
+			input: "testMustFail",
+			expected: struct {
+				result PropertyItemID
+				err    error
+			}{
+				PropertyItemID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "Fail:Not valid string",
+			input: "",
+			expected: struct {
+				result PropertyItemID
+				err    error
+			}{
+				PropertyItemID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "success:valid string",
+			input: "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: struct {
+				result PropertyItemID
+				err    error
+			}{
+				PropertyItemID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+				nil,
+			},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result, err := PropertyItemIDFrom(tc.input)
+			assert.Equal(tt, tc.expected.result, result)
+			if err != nil {
+				assert.True(tt, errors.As(tc.expected.err, &err))
+			}
+		})
+	}
+}
+
+func TestMustPropertyItemID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name        string
+		input       string
+		shouldPanic bool
+		expected    PropertyItemID
+	}{
+		{
+			name:        "Fail:Not valid string",
+			input:       "testMustFail",
+			shouldPanic: true,
+		},
+		{
+			name:        "Fail:Not valid string",
+			input:       "",
+			shouldPanic: true,
+		},
+		{
+			name:        "success:valid string",
+			input:       "01f2r7kg1fvvffp0gmexgy5hxy",
+			shouldPanic: false,
+			expected:    PropertyItemID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.shouldPanic {
+				assert.Panics(tt, func() { MustBeID(tc.input) })
+				return
+			}
+			result := MustPropertyItemID(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
+
+func TestPropertyItemIDFromRef(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected *PropertyItemID
+	}{
+		{
+			name:     "Fail:Not valid string",
+			input:    "testMustFail",
+			expected: nil,
+		},
+		{
+			name:     "Fail:Not valid string",
+			input:    "",
+			expected: nil,
+		},
+		{
+			name:     "success:valid string",
+			input:    "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: &PropertyItemID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := PropertyItemIDFromRef(&tc.input)
+			assert.Equal(tt, tc.expected, result)
+			if tc.expected != nil {
+				assert.Equal(tt, *tc.expected, *result)
+			}
+		})
+	}
+}
+
+func TestPropertyItemIDFromRefID(t *testing.T) {
+	id := New()
+
+	subId := PropertyItemIDFromRefID(&id)
+
+	assert.NotNil(t, subId)
+	assert.Equal(t, subId.id, id.id)
+}
+
+func TestPropertyItemID_ID(t *testing.T) {
+	id := New()
+	subId := PropertyItemIDFromRefID(&id)
+
+	idOrg := subId.ID()
+
+	assert.Equal(t, id, idOrg)
+}
+
+func TestPropertyItemID_String(t *testing.T) {
+	id := New()
+	subId := PropertyItemIDFromRefID(&id)
+
+	assert.Equal(t, subId.String(), id.String())
+}
+
+func TestPropertyItemID_GoString(t *testing.T) {
+	id := New()
+	subId := PropertyItemIDFromRefID(&id)
+
+	assert.Equal(t, subId.GoString(), "id.PropertyItemID("+id.String()+")")
+}
+
+func TestPropertyItemID_RefString(t *testing.T) {
+	id := New()
+	subId := PropertyItemIDFromRefID(&id)
+
+	refString := subId.StringRef()
+
+	assert.NotNil(t, refString)
+	assert.Equal(t, *refString, id.String())
+}
+
+func TestPropertyItemID_Ref(t *testing.T) {
+	id := New()
+	subId := PropertyItemIDFromRefID(&id)
+
+	subIdRef := subId.Ref()
+
+	assert.Equal(t, *subId, *subIdRef)
+}
+
+func TestPropertyItemID_CopyRef(t *testing.T) {
+	id := New()
+	subId := PropertyItemIDFromRefID(&id)
+
+	subIdCopyRef := subId.CopyRef()
+
+	assert.Equal(t, *subId, *subIdCopyRef)
+	assert.NotSame(t, subId, subIdCopyRef)
+}
+
+func TestPropertyItemID_IDRef(t *testing.T) {
+	id := New()
+	subId := PropertyItemIDFromRefID(&id)
+
+	assert.Equal(t, id, *subId.IDRef())
+}
+
+func TestPropertyItemID_StringRef(t *testing.T) {
+	id := New()
+	subId := PropertyItemIDFromRefID(&id)
+
+	assert.Equal(t, *subId.StringRef(), id.String())
+}
+
+func TestPropertyItemID_MarhsalJSON(t *testing.T) {
+	id := New()
+	subId := PropertyItemIDFromRefID(&id)
+
+	res, err := subId.MarhsalJSON()
+	exp, _ := json.Marshal(subId.String())
+
+	assert.Nil(t, err)
+	assert.Equal(t, exp, res)
+}
+
+func TestPropertyItemID_UnmarhsalJSON(t *testing.T) {
+	jsonString := "\"01f3zhkysvcxsnzepyyqtq21fb\""
+
+	subId := &PropertyItemID{}
+
+	err := subId.UnmarhsalJSON([]byte(jsonString))
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhkysvcxsnzepyyqtq21fb", subId.String())
+}
+
+func TestPropertyItemID_MarshalText(t *testing.T) {
+	id := New()
+	subId := PropertyItemIDFromRefID(&id)
+
+	res, err := subId.MarshalText()
+
+	assert.Nil(t, err)
+	assert.Equal(t, []byte(id.String()), res)
+}
+
+func TestPropertyItemID_UnmarshalText(t *testing.T) {
+	text := []byte("01f3zhcaq35403zdjnd6dcm0t2")
+
+	subId := &PropertyItemID{}
+
+	err := subId.UnmarshalText(text)
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhcaq35403zdjnd6dcm0t2", subId.String())
+
+}
+
+func TestPropertyItemID_IsNil(t *testing.T) {
+	subId := PropertyItemID{}
+
+	assert.True(t, subId.IsNil())
+
+	id := New()
+	subId = *PropertyItemIDFromRefID(&id)
+
+	assert.False(t, subId.IsNil())
+}
+
+func TestPropertyItemIDToKeys(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []PropertyItemID
+		expected []string
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]PropertyItemID, 0),
+			expected: make([]string, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []PropertyItemID{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+		},
+		{
+			name: "multiple elements",
+			input: []PropertyItemID{
+				MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, PropertyItemIDToKeys(tc.input))
+		})
+	}
+
+}
+
+func TestPropertyItemIDsFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []string
+		expected struct {
+			res []PropertyItemID
+			err error
+		}
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]string, 0),
+			expected: struct {
+				res []PropertyItemID
+				err error
+			}{
+				res: make([]PropertyItemID, 0),
+				err: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+			expected: struct {
+				res []PropertyItemID
+				err error
+			}{
+				res: []PropertyItemID{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2")},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []PropertyItemID
+				err error
+			}{
+				res: []PropertyItemID{
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []PropertyItemID
+				err error
+			}{
+				res: nil,
+				err: ErrInvalidID,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.expected.err != nil {
+				_, err := PropertyItemIDsFrom(tc.input)
+				assert.True(tt, errors.As(ErrInvalidID, &err))
+			} else {
+				res, err := PropertyItemIDsFrom(tc.input)
+				assert.Equal(tt, tc.expected.res, res)
+				assert.Nil(tt, err)
+			}
+
+		})
+	}
+}
+
+func TestPropertyItemIDsFromID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []ID
+		expected []PropertyItemID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]ID, 0),
+			expected: make([]PropertyItemID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []PropertyItemID{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []PropertyItemID{
+				MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := PropertyItemIDsFromID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestPropertyItemIDsFromIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+
+	testCases := []struct {
+		name     string
+		input    []*ID
+		expected []PropertyItemID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*ID, 0),
+			expected: make([]PropertyItemID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*ID{&id1},
+			expected: []PropertyItemID{MustPropertyItemID(id1.String())},
+		},
+		{
+			name:  "multiple elements",
+			input: []*ID{&id1, &id2, &id3},
+			expected: []PropertyItemID{
+				MustPropertyItemID(id1.String()),
+				MustPropertyItemID(id2.String()),
+				MustPropertyItemID(id3.String()),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := PropertyItemIDsFromIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestPropertyItemIDsToID(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []PropertyItemID
+		expected []ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]PropertyItemID, 0),
+			expected: make([]ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []PropertyItemID{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []PropertyItemID{
+				MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := PropertyItemIDsToID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestPropertyItemIDsToIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	subId1 := MustPropertyItemID(id1.String())
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	subId2 := MustPropertyItemID(id2.String())
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+	subId3 := MustPropertyItemID(id3.String())
+
+	testCases := []struct {
+		name     string
+		input    []*PropertyItemID
+		expected []*ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*PropertyItemID, 0),
+			expected: make([]*ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*PropertyItemID{&subId1},
+			expected: []*ID{&id1},
+		},
+		{
+			name:     "multiple elements",
+			input:    []*PropertyItemID{&subId1, &subId2, &subId3},
+			expected: []*ID{&id1, &id2, &id3},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := PropertyItemIDsToIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestNewPropertyItemIDSet(t *testing.T) {
+	PropertyItemIdSet := NewPropertyItemIDSet()
+
+	assert.NotNil(t, PropertyItemIdSet)
+	assert.Empty(t, PropertyItemIdSet.m)
+	assert.Empty(t, PropertyItemIdSet.s)
+}
+
+func TestPropertyItemIDSet_Add(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []PropertyItemID
+		expected *PropertyItemIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]PropertyItemID, 0),
+			expected: &PropertyItemIDSet{
+				m: map[PropertyItemID]struct{}{},
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []PropertyItemID{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: &PropertyItemIDSet{
+				m: map[PropertyItemID]struct{}{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []PropertyItemID{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []PropertyItemID{
+				MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &PropertyItemIDSet{
+				m: map[PropertyItemID]struct{}{
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []PropertyItemID{
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+		{
+			name: "multiple elements with duplication",
+			input: []PropertyItemID{
+				MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &PropertyItemIDSet{
+				m: map[PropertyItemID]struct{}{
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []PropertyItemID{
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewPropertyItemIDSet()
+			set.Add(tc.input...)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestPropertyItemIDSet_AddRef(t *testing.T) {
+	t.Parallel()
+
+	PropertyItemId := MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1")
+
+	testCases := []struct {
+		name     string
+		input    *PropertyItemID
+		expected *PropertyItemIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: nil,
+			expected: &PropertyItemIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: &PropertyItemId,
+			expected: &PropertyItemIDSet{
+				m: map[PropertyItemID]struct{}{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []PropertyItemID{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewPropertyItemIDSet()
+			set.AddRef(tc.input)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestPropertyItemIDSet_Has(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			PropertyItemIDSet
+			PropertyItemID
+		}
+		expected bool
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				PropertyItemIDSet
+				PropertyItemID
+			}{PropertyItemIDSet: PropertyItemIDSet{}, PropertyItemID: MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: false,
+		},
+		{
+			name: "Set Contains the element",
+			input: struct {
+				PropertyItemIDSet
+				PropertyItemID
+			}{PropertyItemIDSet: PropertyItemIDSet{
+				m: map[PropertyItemID]struct{}{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []PropertyItemID{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, PropertyItemID: MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: true,
+		},
+		{
+			name: "Set does not Contains the element",
+			input: struct {
+				PropertyItemIDSet
+				PropertyItemID
+			}{PropertyItemIDSet: PropertyItemIDSet{
+				m: map[PropertyItemID]struct{}{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []PropertyItemID{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, PropertyItemID: MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, tc.input.PropertyItemIDSet.Has(tc.input.PropertyItemID))
+		})
+	}
+}
+
+func TestPropertyItemIDSet_Clear(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    PropertyItemIDSet
+		expected PropertyItemIDSet
+	}{
+		{
+			name:  "Empty Set",
+			input: PropertyItemIDSet{},
+			expected: PropertyItemIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name: "Set Contains the element",
+			input: PropertyItemIDSet{
+				m: map[PropertyItemID]struct{}{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []PropertyItemID{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: PropertyItemIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			set := tc.input
+			p := &set
+			p.Clear()
+			assert.Equal(tt, tc.expected, *p)
+		})
+	}
+}
+
+func TestPropertyItemIDSet_All(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *PropertyItemIDSet
+		expected []PropertyItemID
+	}{
+		{
+			name: "Empty slice",
+			input: &PropertyItemIDSet{
+				m: map[PropertyItemID]struct{}{},
+				s: nil,
+			},
+			expected: make([]PropertyItemID, 0),
+		},
+		{
+			name: "1 element",
+			input: &PropertyItemIDSet{
+				m: map[PropertyItemID]struct{}{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []PropertyItemID{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: []PropertyItemID{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1")},
+		},
+		{
+			name: "multiple elements",
+			input: &PropertyItemIDSet{
+				m: map[PropertyItemID]struct{}{
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []PropertyItemID{
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: []PropertyItemID{
+				MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.All())
+		})
+	}
+}
+
+func TestPropertyItemIDSet_Clone(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *PropertyItemIDSet
+		expected *PropertyItemIDSet
+	}{
+		{
+			name:     "nil set",
+			input:    nil,
+			expected: NewPropertyItemIDSet(),
+		},
+		{
+			name:     "Empty set",
+			input:    NewPropertyItemIDSet(),
+			expected: NewPropertyItemIDSet(),
+		},
+		{
+			name: "1 element",
+			input: &PropertyItemIDSet{
+				m: map[PropertyItemID]struct{}{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []PropertyItemID{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: &PropertyItemIDSet{
+				m: map[PropertyItemID]struct{}{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []PropertyItemID{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: &PropertyItemIDSet{
+				m: map[PropertyItemID]struct{}{
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []PropertyItemID{
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: &PropertyItemIDSet{
+				m: map[PropertyItemID]struct{}{
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []PropertyItemID{
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			clone := tc.input.Clone()
+			assert.Equal(tt, tc.expected, clone)
+			assert.False(tt, tc.input == clone)
+		})
+	}
+}
+
+func TestPropertyItemIDSet_Merge(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			a *PropertyItemIDSet
+			b *PropertyItemIDSet
+		}
+		expected *PropertyItemIDSet
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				a *PropertyItemIDSet
+				b *PropertyItemIDSet
+			}{
+				a: &PropertyItemIDSet{},
+				b: &PropertyItemIDSet{},
+			},
+			expected: &PropertyItemIDSet{},
+		},
+		{
+			name: "1 Empty Set",
+			input: struct {
+				a *PropertyItemIDSet
+				b *PropertyItemIDSet
+			}{
+				a: &PropertyItemIDSet{
+					m: map[PropertyItemID]struct{}{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []PropertyItemID{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &PropertyItemIDSet{},
+			},
+			expected: &PropertyItemIDSet{
+				m: map[PropertyItemID]struct{}{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []PropertyItemID{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "2 non Empty Set",
+			input: struct {
+				a *PropertyItemIDSet
+				b *PropertyItemIDSet
+			}{
+				a: &PropertyItemIDSet{
+					m: map[PropertyItemID]struct{}{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []PropertyItemID{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &PropertyItemIDSet{
+					m: map[PropertyItemID]struct{}{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{}},
+					s: []PropertyItemID{MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2")},
+				},
+			},
+			expected: &PropertyItemIDSet{
+				m: map[PropertyItemID]struct{}{
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+				},
+				s: []PropertyItemID{
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustPropertyItemID("01f3zhcaq35403zdjnd6dcm0t2"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.a.Merge(tc.input.b))
+		})
+	}
+}
diff --git a/pkg/id/property_schema_field_test.go b/pkg/id/property_schema_field_test.go
new file mode 100644
index 00000000..0f985077
--- /dev/null
+++ b/pkg/id/property_schema_field_test.go
@@ -0,0 +1,63 @@
+package id
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPropertySchemaFieldIDFrom(t *testing.T) {
+	t.Parallel()
+	input1 := "testStringId"
+	expected1 := PropertySchemaFieldID(input1)
+	testCases := []struct {
+		name     string
+		input    *string
+		expected *PropertySchemaFieldID
+	}{
+		{
+			name:     "success:string input",
+			input:    &input1,
+			expected: &expected1,
+		},
+		{
+			name:     "fail:nil pointer",
+			input:    nil,
+			expected: nil,
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := PropertySchemaFieldIDFrom(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
+
+func TestPropertySchemaFieldID_Ref(t *testing.T) {
+	propertySchemaFieldID := PropertySchemaFieldID("test")
+
+	assert.Equal(t, &propertySchemaFieldID, propertySchemaFieldID.Ref())
+}
+
+func TestPropertySchemaFieldID_CopyRef(t *testing.T) {
+	propertySchemaFieldID := PropertySchemaFieldID("test")
+
+	assert.Equal(t, propertySchemaFieldID, *propertySchemaFieldID.CopyRef())
+
+	assert.False(t, propertySchemaFieldID.Ref() == propertySchemaFieldID.CopyRef())
+}
+
+func TestPropertySchemaFieldID_String(t *testing.T) {
+	propertySchemaFieldID := PropertySchemaFieldID("test")
+
+	assert.Equal(t, "test", propertySchemaFieldID.String())
+}
+
+func TestPropertySchemaFieldID_StringRef(t *testing.T) {
+	propertySchemaFieldID := PropertySchemaFieldID("test")
+
+	assert.Equal(t, "test", *propertySchemaFieldID.StringRef())
+}
diff --git a/pkg/id/property_schema_test.go b/pkg/id/property_schema_test.go
index b8dc2eb5..f40f881d 100644
--- a/pkg/id/property_schema_test.go
+++ b/pkg/id/property_schema_test.go
@@ -2,7 +2,430 @@ package id
 
 import (
 	"encoding"
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 var _ encoding.TextMarshaler = (*PropertySchemaID)(nil)
 var _ encoding.TextUnmarshaler = (*PropertySchemaID)(nil)
+
+func TestPropertySchemaIDFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			result PropertySchemaID
+			err    error
+		}
+	}{
+		{
+			name:  "success:valid name",
+			input: "test/Test_Test-01",
+			expected: struct {
+				result PropertySchemaID
+				err    error
+			}{
+				result: PropertySchemaID{
+					plugin: "test",
+					id:     "Test_Test-01",
+				},
+				err: nil,
+			},
+		},
+		{
+			name:  "fail:invalid name",
+			input: "Test",
+			expected: struct {
+				result PropertySchemaID
+				err    error
+			}{result: PropertySchemaID{}, err: ErrInvalidID},
+		},
+		{
+			name:  "fail:invalid name",
+			input: "Test/+dsad",
+			expected: struct {
+				result PropertySchemaID
+				err    error
+			}{result: PropertySchemaID{}, err: ErrInvalidID},
+		},
+		{
+			name:  "fail:invalid name",
+			input: "Test/dsa d",
+			expected: struct {
+				result PropertySchemaID
+				err    error
+			}{result: PropertySchemaID{}, err: ErrInvalidID},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result, err := PropertySchemaIDFrom(tc.input)
+			if tc.expected.err != nil {
+				assert.Equal(tt, tc.expected.result, result)
+				assert.True(tt, errors.As(tc.expected.err, &err))
+			} else {
+				assert.Equal(tt, tc.expected.result, result)
+				assert.Nil(tt, err)
+			}
+
+		})
+	}
+}
+
+func TestPropertySchemaIDFromExtension(t *testing.T) {
+	pluginID := MustPluginID("test#2.0.0")
+	pluginExtensionID := PluginExtensionID("test2")
+
+	propertySchemaID, err := PropertySchemaIDFromExtension(pluginID, pluginExtensionID)
+
+	assert.NotNil(t, propertySchemaID)
+	assert.Equal(t, PropertySchemaID{
+		plugin: "test#2.0.0",
+		id:     "test2",
+	}, propertySchemaID)
+	assert.Nil(t, err)
+}
+
+func TestMustPropertySchemaID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			result PropertySchemaID
+			err    error
+		}
+	}{
+		{
+			name:  "success:valid name",
+			input: "test/Test_Test-01",
+			expected: struct {
+				result PropertySchemaID
+				err    error
+			}{
+				result: PropertySchemaID{
+					plugin: "test",
+					id:     "Test_Test-01",
+				},
+				err: nil,
+			},
+		},
+		{
+			name:  "fail:invalid name",
+			input: "Test",
+			expected: struct {
+				result PropertySchemaID
+				err    error
+			}{result: PropertySchemaID{}, err: ErrInvalidID},
+		},
+		{
+			name:  "fail:invalid name",
+			input: "Test/+dsad",
+			expected: struct {
+				result PropertySchemaID
+				err    error
+			}{result: PropertySchemaID{}, err: ErrInvalidID},
+		},
+		{
+			name:  "fail:invalid name",
+			input: "Test/dsa d",
+			expected: struct {
+				result PropertySchemaID
+				err    error
+			}{result: PropertySchemaID{}, err: ErrInvalidID},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.expected.err != nil {
+				assert.Panics(tt, func() {
+					_ = MustPropertySchemaID(tc.input)
+				})
+			} else {
+				result := MustPropertySchemaID(tc.input)
+				assert.Equal(tt, tc.expected.result, result)
+			}
+
+		})
+	}
+}
+
+func TestMustPropertySchemaIDFromExtension(t *testing.T) {
+	pluginID := MustPluginID("test#2.0.0")
+	pluginExtensionID := PluginExtensionID("test2")
+
+	propertySchemaID := MustPropertySchemaIDFromExtension(pluginID, pluginExtensionID)
+
+	assert.NotNil(t, propertySchemaID)
+	assert.Equal(t, PropertySchemaID{
+		plugin: "test#2.0.0",
+		id:     "test2",
+	}, propertySchemaID)
+}
+
+func TestPropertySchemaIDFromRef(t *testing.T) {
+	t.Parallel()
+	input1 := "test/Test_Test-01"
+	input2 := "Test"
+	input3 := "Test/+dsad"
+	input4 := "Test/dsa d"
+	testCases := []struct {
+		name     string
+		input    *string
+		expected *PropertySchemaID
+	}{
+		{
+			name:  "success:valid name",
+			input: &input1,
+			expected: &PropertySchemaID{
+				plugin: "test",
+				id:     "Test_Test-01",
+			},
+		},
+		{
+			name:     "fail:invalid name",
+			input:    &input2,
+			expected: nil,
+		},
+		{
+			name:     "fail:invalid name",
+			input:    &input3,
+			expected: nil,
+		},
+		{
+			name:     "fail:invalid name",
+			input:    &input4,
+			expected: nil,
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			result := PropertySchemaIDFromRef(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
+
+func TestPropertySchemaID_ID(t *testing.T) {
+	propertySchemaID := MustPropertySchemaID("Test#2.0.0/test")
+
+	assert.Equal(t, propertySchemaID.ID(), "test")
+}
+
+func TestPropertySchemaID_Plugin(t *testing.T) {
+	propertySchemaID := MustPropertySchemaID("Test#2.0.0/test")
+
+	assert.Equal(t, propertySchemaID.Plugin(), "Test#2.0.0")
+}
+
+func TestPropertySchemaID_System(t *testing.T) {
+	propertySchemaID := MustPropertySchemaID("Test#2.0.0/test")
+
+	assert.False(t, propertySchemaID.System())
+
+	extinctionName := schemaSystemIDPrefix
+	propertySchemaID = MustPropertySchemaIDFromExtension(MustPluginID("test#2.0.0"), *PluginExtensionIDFromRef(&extinctionName))
+
+	assert.True(t, propertySchemaID.System())
+
+	propertySchemaID = MustPropertySchemaID("Test#2.0.0/" + schemaSystemIDPrefix)
+
+	assert.True(t, propertySchemaID.System())
+}
+
+func TestPropertySchemaID_String(t *testing.T) {
+	propertySchemaID := MustPropertySchemaID("Test#2.0.0/test")
+
+	assert.Equal(t, propertySchemaID.String(), "Test#2.0.0/test")
+}
+
+func TestPropertySchemaID_Ref(t *testing.T) {
+	propertySchemaID, _ := PropertySchemaIDFrom("test#2.0.0/test")
+
+	assert.Equal(t, &propertySchemaID, propertySchemaID.Ref())
+}
+
+func TestPropertySchemaID_CopyRef(t *testing.T) {
+	propertySchemaID, _ := PropertySchemaIDFrom("test#2.0.0/test")
+
+	assert.Equal(t, propertySchemaID, *propertySchemaID.CopyRef())
+
+	assert.False(t, propertySchemaID.Ref() == propertySchemaID.CopyRef())
+}
+
+func TestPropertySchemaID_IsNil(t *testing.T) {
+	propertySchemaID, _ := PropertySchemaIDFrom("test#2.0.0/test")
+
+	assert.False(t, propertySchemaID.IsNil())
+
+	propertySchemaID = PropertySchemaID{}
+
+	assert.True(t, propertySchemaID.IsNil())
+}
+
+func TestPropertySchemaID_StringRef(t *testing.T) {
+	propertySchemaID, _ := PropertySchemaIDFrom("test#2.0.0/test")
+
+	ref := &propertySchemaID
+
+	assert.Equal(t, *ref.StringRef(), ref.String())
+}
+
+func TestPropertySchemaID_MarshalText(t *testing.T) {
+	propertySchemaID, _ := PropertySchemaIDFrom("test#2.0.0/test")
+
+	res, err := propertySchemaID.MarshalText()
+
+	assert.Nil(t, err)
+	assert.Equal(t, []byte("test#2.0.0/test"), res)
+}
+
+func TestPropertySchemaID_UnmarshalText(t *testing.T) {
+	text := []byte("test#2.0.0/test")
+
+	propertySchemaID := &PropertySchemaID{}
+
+	err := propertySchemaID.UnmarshalText(text)
+
+	assert.Nil(t, err)
+	assert.Equal(t, "test#2.0.0/test", propertySchemaID.String())
+}
+
+func TestPropertySchemaIDToKeys(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []PropertySchemaID
+		expected []string
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]PropertySchemaID, 0),
+			expected: make([]string, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []PropertySchemaID{MustPropertySchemaID("test#2.0.0/test")},
+			expected: []string{"test#2.0.0/test"},
+		},
+		{
+			name: "multiple elements",
+			input: []PropertySchemaID{
+				MustPropertySchemaID("Test#1.0.0/test"),
+				MustPropertySchemaID("Test#1.0.1/test"),
+				MustPropertySchemaID("Test#1.0.2/test"),
+			},
+			expected: []string{
+				"Test#1.0.0/test",
+				"Test#1.0.1/test",
+				"Test#1.0.2/test",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, PropertySchemaIDToKeys(tc.input))
+		})
+	}
+
+}
+
+func TestPropertySchemaIDsFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []string
+		expected struct {
+			res []PropertySchemaID
+			err error
+		}
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]string, 0),
+			expected: struct {
+				res []PropertySchemaID
+				err error
+			}{
+				res: make([]PropertySchemaID, 0),
+				err: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []string{"Test#1.0.0/test"},
+			expected: struct {
+				res []PropertySchemaID
+				err error
+			}{
+				res: []PropertySchemaID{MustPropertySchemaID("Test#1.0.0/test")},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"Test#1.0.0/test",
+				"Test#1.0.1/test",
+				"Test#1.0.2/test",
+			},
+			expected: struct {
+				res []PropertySchemaID
+				err error
+			}{
+				res: []PropertySchemaID{
+					MustPropertySchemaID("Test#1.0.0/test"),
+					MustPropertySchemaID("Test#1.0.1/test"),
+					MustPropertySchemaID("Test#1.0.2/test"),
+				},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"Test#1.0.0/test",
+				"Test#1.0.1/test",
+				"Test#1.0.2/test",
+			},
+			expected: struct {
+				res []PropertySchemaID
+				err error
+			}{
+				res: nil,
+				err: ErrInvalidID,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.expected.err != nil {
+				_, err := PropertySchemaIDsFrom(tc.input)
+				assert.True(tt, errors.As(ErrInvalidID, &err))
+			} else {
+				res, err := PropertySchemaIDsFrom(tc.input)
+				assert.Equal(tt, tc.expected.res, res)
+				assert.Nil(tt, err)
+			}
+
+		})
+	}
+}
diff --git a/pkg/id/scene_gen_test.go b/pkg/id/scene_gen_test.go
new file mode 100644
index 00000000..d8b3928c
--- /dev/null
+++ b/pkg/id/scene_gen_test.go
@@ -0,0 +1,1004 @@
+// Code generated by gen, DO NOT EDIT.
+
+package id
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/oklog/ulid"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewSceneID(t *testing.T) {
+	id := NewSceneID()
+	assert.NotNil(t, id)
+	ulID, err := ulid.Parse(id.String())
+
+	assert.NotNil(t, ulID)
+	assert.Nil(t, err)
+}
+
+func TestSceneIDFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			result SceneID
+			err    error
+		}
+	}{
+		{
+			name:  "Fail:Not valid string",
+			input: "testMustFail",
+			expected: struct {
+				result SceneID
+				err    error
+			}{
+				SceneID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "Fail:Not valid string",
+			input: "",
+			expected: struct {
+				result SceneID
+				err    error
+			}{
+				SceneID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "success:valid string",
+			input: "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: struct {
+				result SceneID
+				err    error
+			}{
+				SceneID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+				nil,
+			},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result, err := SceneIDFrom(tc.input)
+			assert.Equal(tt, tc.expected.result, result)
+			if err != nil {
+				assert.True(tt, errors.As(tc.expected.err, &err))
+			}
+		})
+	}
+}
+
+func TestMustSceneID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name        string
+		input       string
+		shouldPanic bool
+		expected    SceneID
+	}{
+		{
+			name:        "Fail:Not valid string",
+			input:       "testMustFail",
+			shouldPanic: true,
+		},
+		{
+			name:        "Fail:Not valid string",
+			input:       "",
+			shouldPanic: true,
+		},
+		{
+			name:        "success:valid string",
+			input:       "01f2r7kg1fvvffp0gmexgy5hxy",
+			shouldPanic: false,
+			expected:    SceneID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.shouldPanic {
+				assert.Panics(tt, func() { MustBeID(tc.input) })
+				return
+			}
+			result := MustSceneID(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
+
+func TestSceneIDFromRef(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected *SceneID
+	}{
+		{
+			name:     "Fail:Not valid string",
+			input:    "testMustFail",
+			expected: nil,
+		},
+		{
+			name:     "Fail:Not valid string",
+			input:    "",
+			expected: nil,
+		},
+		{
+			name:     "success:valid string",
+			input:    "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: &SceneID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := SceneIDFromRef(&tc.input)
+			assert.Equal(tt, tc.expected, result)
+			if tc.expected != nil {
+				assert.Equal(tt, *tc.expected, *result)
+			}
+		})
+	}
+}
+
+func TestSceneIDFromRefID(t *testing.T) {
+	id := New()
+
+	subId := SceneIDFromRefID(&id)
+
+	assert.NotNil(t, subId)
+	assert.Equal(t, subId.id, id.id)
+}
+
+func TestSceneID_ID(t *testing.T) {
+	id := New()
+	subId := SceneIDFromRefID(&id)
+
+	idOrg := subId.ID()
+
+	assert.Equal(t, id, idOrg)
+}
+
+func TestSceneID_String(t *testing.T) {
+	id := New()
+	subId := SceneIDFromRefID(&id)
+
+	assert.Equal(t, subId.String(), id.String())
+}
+
+func TestSceneID_GoString(t *testing.T) {
+	id := New()
+	subId := SceneIDFromRefID(&id)
+
+	assert.Equal(t, subId.GoString(), "id.SceneID("+id.String()+")")
+}
+
+func TestSceneID_RefString(t *testing.T) {
+	id := New()
+	subId := SceneIDFromRefID(&id)
+
+	refString := subId.StringRef()
+
+	assert.NotNil(t, refString)
+	assert.Equal(t, *refString, id.String())
+}
+
+func TestSceneID_Ref(t *testing.T) {
+	id := New()
+	subId := SceneIDFromRefID(&id)
+
+	subIdRef := subId.Ref()
+
+	assert.Equal(t, *subId, *subIdRef)
+}
+
+func TestSceneID_CopyRef(t *testing.T) {
+	id := New()
+	subId := SceneIDFromRefID(&id)
+
+	subIdCopyRef := subId.CopyRef()
+
+	assert.Equal(t, *subId, *subIdCopyRef)
+	assert.NotSame(t, subId, subIdCopyRef)
+}
+
+func TestSceneID_IDRef(t *testing.T) {
+	id := New()
+	subId := SceneIDFromRefID(&id)
+
+	assert.Equal(t, id, *subId.IDRef())
+}
+
+func TestSceneID_StringRef(t *testing.T) {
+	id := New()
+	subId := SceneIDFromRefID(&id)
+
+	assert.Equal(t, *subId.StringRef(), id.String())
+}
+
+func TestSceneID_MarhsalJSON(t *testing.T) {
+	id := New()
+	subId := SceneIDFromRefID(&id)
+
+	res, err := subId.MarhsalJSON()
+	exp, _ := json.Marshal(subId.String())
+
+	assert.Nil(t, err)
+	assert.Equal(t, exp, res)
+}
+
+func TestSceneID_UnmarhsalJSON(t *testing.T) {
+	jsonString := "\"01f3zhkysvcxsnzepyyqtq21fb\""
+
+	subId := &SceneID{}
+
+	err := subId.UnmarhsalJSON([]byte(jsonString))
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhkysvcxsnzepyyqtq21fb", subId.String())
+}
+
+func TestSceneID_MarshalText(t *testing.T) {
+	id := New()
+	subId := SceneIDFromRefID(&id)
+
+	res, err := subId.MarshalText()
+
+	assert.Nil(t, err)
+	assert.Equal(t, []byte(id.String()), res)
+}
+
+func TestSceneID_UnmarshalText(t *testing.T) {
+	text := []byte("01f3zhcaq35403zdjnd6dcm0t2")
+
+	subId := &SceneID{}
+
+	err := subId.UnmarshalText(text)
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhcaq35403zdjnd6dcm0t2", subId.String())
+
+}
+
+func TestSceneID_IsNil(t *testing.T) {
+	subId := SceneID{}
+
+	assert.True(t, subId.IsNil())
+
+	id := New()
+	subId = *SceneIDFromRefID(&id)
+
+	assert.False(t, subId.IsNil())
+}
+
+func TestSceneIDToKeys(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []SceneID
+		expected []string
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]SceneID, 0),
+			expected: make([]string, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []SceneID{MustSceneID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+		},
+		{
+			name: "multiple elements",
+			input: []SceneID{
+				MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustSceneID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustSceneID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, SceneIDToKeys(tc.input))
+		})
+	}
+
+}
+
+func TestSceneIDsFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []string
+		expected struct {
+			res []SceneID
+			err error
+		}
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]string, 0),
+			expected: struct {
+				res []SceneID
+				err error
+			}{
+				res: make([]SceneID, 0),
+				err: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+			expected: struct {
+				res []SceneID
+				err error
+			}{
+				res: []SceneID{MustSceneID("01f3zhcaq35403zdjnd6dcm0t2")},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []SceneID
+				err error
+			}{
+				res: []SceneID{
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []SceneID
+				err error
+			}{
+				res: nil,
+				err: ErrInvalidID,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.expected.err != nil {
+				_, err := SceneIDsFrom(tc.input)
+				assert.True(tt, errors.As(ErrInvalidID, &err))
+			} else {
+				res, err := SceneIDsFrom(tc.input)
+				assert.Equal(tt, tc.expected.res, res)
+				assert.Nil(tt, err)
+			}
+
+		})
+	}
+}
+
+func TestSceneIDsFromID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []ID
+		expected []SceneID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]ID, 0),
+			expected: make([]SceneID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []SceneID{MustSceneID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []SceneID{
+				MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustSceneID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustSceneID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := SceneIDsFromID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestSceneIDsFromIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+
+	testCases := []struct {
+		name     string
+		input    []*ID
+		expected []SceneID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*ID, 0),
+			expected: make([]SceneID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*ID{&id1},
+			expected: []SceneID{MustSceneID(id1.String())},
+		},
+		{
+			name:  "multiple elements",
+			input: []*ID{&id1, &id2, &id3},
+			expected: []SceneID{
+				MustSceneID(id1.String()),
+				MustSceneID(id2.String()),
+				MustSceneID(id3.String()),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := SceneIDsFromIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestSceneIDsToID(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []SceneID
+		expected []ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]SceneID, 0),
+			expected: make([]ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []SceneID{MustSceneID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []SceneID{
+				MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustSceneID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustSceneID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := SceneIDsToID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestSceneIDsToIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	subId1 := MustSceneID(id1.String())
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	subId2 := MustSceneID(id2.String())
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+	subId3 := MustSceneID(id3.String())
+
+	testCases := []struct {
+		name     string
+		input    []*SceneID
+		expected []*ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*SceneID, 0),
+			expected: make([]*ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*SceneID{&subId1},
+			expected: []*ID{&id1},
+		},
+		{
+			name:     "multiple elements",
+			input:    []*SceneID{&subId1, &subId2, &subId3},
+			expected: []*ID{&id1, &id2, &id3},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := SceneIDsToIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestNewSceneIDSet(t *testing.T) {
+	SceneIdSet := NewSceneIDSet()
+
+	assert.NotNil(t, SceneIdSet)
+	assert.Empty(t, SceneIdSet.m)
+	assert.Empty(t, SceneIdSet.s)
+}
+
+func TestSceneIDSet_Add(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []SceneID
+		expected *SceneIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]SceneID, 0),
+			expected: &SceneIDSet{
+				m: map[SceneID]struct{}{},
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []SceneID{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: &SceneIDSet{
+				m: map[SceneID]struct{}{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []SceneID{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []SceneID{
+				MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustSceneID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustSceneID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &SceneIDSet{
+				m: map[SceneID]struct{}{
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []SceneID{
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+		{
+			name: "multiple elements with duplication",
+			input: []SceneID{
+				MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustSceneID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &SceneIDSet{
+				m: map[SceneID]struct{}{
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []SceneID{
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewSceneIDSet()
+			set.Add(tc.input...)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestSceneIDSet_AddRef(t *testing.T) {
+	t.Parallel()
+
+	SceneId := MustSceneID("01f3zhcaq35403zdjnd6dcm0t1")
+
+	testCases := []struct {
+		name     string
+		input    *SceneID
+		expected *SceneIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: nil,
+			expected: &SceneIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: &SceneId,
+			expected: &SceneIDSet{
+				m: map[SceneID]struct{}{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []SceneID{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewSceneIDSet()
+			set.AddRef(tc.input)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestSceneIDSet_Has(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			SceneIDSet
+			SceneID
+		}
+		expected bool
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				SceneIDSet
+				SceneID
+			}{SceneIDSet: SceneIDSet{}, SceneID: MustSceneID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: false,
+		},
+		{
+			name: "Set Contains the element",
+			input: struct {
+				SceneIDSet
+				SceneID
+			}{SceneIDSet: SceneIDSet{
+				m: map[SceneID]struct{}{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []SceneID{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, SceneID: MustSceneID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: true,
+		},
+		{
+			name: "Set does not Contains the element",
+			input: struct {
+				SceneIDSet
+				SceneID
+			}{SceneIDSet: SceneIDSet{
+				m: map[SceneID]struct{}{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []SceneID{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, SceneID: MustSceneID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, tc.input.SceneIDSet.Has(tc.input.SceneID))
+		})
+	}
+}
+
+func TestSceneIDSet_Clear(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    SceneIDSet
+		expected SceneIDSet
+	}{
+		{
+			name:  "Empty Set",
+			input: SceneIDSet{},
+			expected: SceneIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name: "Set Contains the element",
+			input: SceneIDSet{
+				m: map[SceneID]struct{}{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []SceneID{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: SceneIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			set := tc.input
+			p := &set
+			p.Clear()
+			assert.Equal(tt, tc.expected, *p)
+		})
+	}
+}
+
+func TestSceneIDSet_All(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *SceneIDSet
+		expected []SceneID
+	}{
+		{
+			name: "Empty slice",
+			input: &SceneIDSet{
+				m: map[SceneID]struct{}{},
+				s: nil,
+			},
+			expected: make([]SceneID, 0),
+		},
+		{
+			name: "1 element",
+			input: &SceneIDSet{
+				m: map[SceneID]struct{}{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []SceneID{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: []SceneID{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1")},
+		},
+		{
+			name: "multiple elements",
+			input: &SceneIDSet{
+				m: map[SceneID]struct{}{
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []SceneID{
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: []SceneID{
+				MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustSceneID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustSceneID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.All())
+		})
+	}
+}
+
+func TestSceneIDSet_Clone(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *SceneIDSet
+		expected *SceneIDSet
+	}{
+		{
+			name:     "nil set",
+			input:    nil,
+			expected: NewSceneIDSet(),
+		},
+		{
+			name:     "Empty set",
+			input:    NewSceneIDSet(),
+			expected: NewSceneIDSet(),
+		},
+		{
+			name: "1 element",
+			input: &SceneIDSet{
+				m: map[SceneID]struct{}{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []SceneID{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: &SceneIDSet{
+				m: map[SceneID]struct{}{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []SceneID{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: &SceneIDSet{
+				m: map[SceneID]struct{}{
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []SceneID{
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: &SceneIDSet{
+				m: map[SceneID]struct{}{
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []SceneID{
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			clone := tc.input.Clone()
+			assert.Equal(tt, tc.expected, clone)
+			assert.False(tt, tc.input == clone)
+		})
+	}
+}
+
+func TestSceneIDSet_Merge(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			a *SceneIDSet
+			b *SceneIDSet
+		}
+		expected *SceneIDSet
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				a *SceneIDSet
+				b *SceneIDSet
+			}{
+				a: &SceneIDSet{},
+				b: &SceneIDSet{},
+			},
+			expected: &SceneIDSet{},
+		},
+		{
+			name: "1 Empty Set",
+			input: struct {
+				a *SceneIDSet
+				b *SceneIDSet
+			}{
+				a: &SceneIDSet{
+					m: map[SceneID]struct{}{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []SceneID{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &SceneIDSet{},
+			},
+			expected: &SceneIDSet{
+				m: map[SceneID]struct{}{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []SceneID{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "2 non Empty Set",
+			input: struct {
+				a *SceneIDSet
+				b *SceneIDSet
+			}{
+				a: &SceneIDSet{
+					m: map[SceneID]struct{}{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []SceneID{MustSceneID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &SceneIDSet{
+					m: map[SceneID]struct{}{MustSceneID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{}},
+					s: []SceneID{MustSceneID("01f3zhcaq35403zdjnd6dcm0t2")},
+				},
+			},
+			expected: &SceneIDSet{
+				m: map[SceneID]struct{}{
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+				},
+				s: []SceneID{
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustSceneID("01f3zhcaq35403zdjnd6dcm0t2"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.a.Merge(tc.input.b))
+		})
+	}
+}
diff --git a/pkg/id/team_gen_test.go b/pkg/id/team_gen_test.go
new file mode 100644
index 00000000..80ca77e7
--- /dev/null
+++ b/pkg/id/team_gen_test.go
@@ -0,0 +1,1004 @@
+// Code generated by gen, DO NOT EDIT.
+
+package id
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/oklog/ulid"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewTeamID(t *testing.T) {
+	id := NewTeamID()
+	assert.NotNil(t, id)
+	ulID, err := ulid.Parse(id.String())
+
+	assert.NotNil(t, ulID)
+	assert.Nil(t, err)
+}
+
+func TestTeamIDFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			result TeamID
+			err    error
+		}
+	}{
+		{
+			name:  "Fail:Not valid string",
+			input: "testMustFail",
+			expected: struct {
+				result TeamID
+				err    error
+			}{
+				TeamID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "Fail:Not valid string",
+			input: "",
+			expected: struct {
+				result TeamID
+				err    error
+			}{
+				TeamID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "success:valid string",
+			input: "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: struct {
+				result TeamID
+				err    error
+			}{
+				TeamID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+				nil,
+			},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result, err := TeamIDFrom(tc.input)
+			assert.Equal(tt, tc.expected.result, result)
+			if err != nil {
+				assert.True(tt, errors.As(tc.expected.err, &err))
+			}
+		})
+	}
+}
+
+func TestMustTeamID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name        string
+		input       string
+		shouldPanic bool
+		expected    TeamID
+	}{
+		{
+			name:        "Fail:Not valid string",
+			input:       "testMustFail",
+			shouldPanic: true,
+		},
+		{
+			name:        "Fail:Not valid string",
+			input:       "",
+			shouldPanic: true,
+		},
+		{
+			name:        "success:valid string",
+			input:       "01f2r7kg1fvvffp0gmexgy5hxy",
+			shouldPanic: false,
+			expected:    TeamID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.shouldPanic {
+				assert.Panics(tt, func() { MustBeID(tc.input) })
+				return
+			}
+			result := MustTeamID(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
+
+func TestTeamIDFromRef(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected *TeamID
+	}{
+		{
+			name:     "Fail:Not valid string",
+			input:    "testMustFail",
+			expected: nil,
+		},
+		{
+			name:     "Fail:Not valid string",
+			input:    "",
+			expected: nil,
+		},
+		{
+			name:     "success:valid string",
+			input:    "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: &TeamID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := TeamIDFromRef(&tc.input)
+			assert.Equal(tt, tc.expected, result)
+			if tc.expected != nil {
+				assert.Equal(tt, *tc.expected, *result)
+			}
+		})
+	}
+}
+
+func TestTeamIDFromRefID(t *testing.T) {
+	id := New()
+
+	subId := TeamIDFromRefID(&id)
+
+	assert.NotNil(t, subId)
+	assert.Equal(t, subId.id, id.id)
+}
+
+func TestTeamID_ID(t *testing.T) {
+	id := New()
+	subId := TeamIDFromRefID(&id)
+
+	idOrg := subId.ID()
+
+	assert.Equal(t, id, idOrg)
+}
+
+func TestTeamID_String(t *testing.T) {
+	id := New()
+	subId := TeamIDFromRefID(&id)
+
+	assert.Equal(t, subId.String(), id.String())
+}
+
+func TestTeamID_GoString(t *testing.T) {
+	id := New()
+	subId := TeamIDFromRefID(&id)
+
+	assert.Equal(t, subId.GoString(), "id.TeamID("+id.String()+")")
+}
+
+func TestTeamID_RefString(t *testing.T) {
+	id := New()
+	subId := TeamIDFromRefID(&id)
+
+	refString := subId.StringRef()
+
+	assert.NotNil(t, refString)
+	assert.Equal(t, *refString, id.String())
+}
+
+func TestTeamID_Ref(t *testing.T) {
+	id := New()
+	subId := TeamIDFromRefID(&id)
+
+	subIdRef := subId.Ref()
+
+	assert.Equal(t, *subId, *subIdRef)
+}
+
+func TestTeamID_CopyRef(t *testing.T) {
+	id := New()
+	subId := TeamIDFromRefID(&id)
+
+	subIdCopyRef := subId.CopyRef()
+
+	assert.Equal(t, *subId, *subIdCopyRef)
+	assert.NotSame(t, subId, subIdCopyRef)
+}
+
+func TestTeamID_IDRef(t *testing.T) {
+	id := New()
+	subId := TeamIDFromRefID(&id)
+
+	assert.Equal(t, id, *subId.IDRef())
+}
+
+func TestTeamID_StringRef(t *testing.T) {
+	id := New()
+	subId := TeamIDFromRefID(&id)
+
+	assert.Equal(t, *subId.StringRef(), id.String())
+}
+
+func TestTeamID_MarhsalJSON(t *testing.T) {
+	id := New()
+	subId := TeamIDFromRefID(&id)
+
+	res, err := subId.MarhsalJSON()
+	exp, _ := json.Marshal(subId.String())
+
+	assert.Nil(t, err)
+	assert.Equal(t, exp, res)
+}
+
+func TestTeamID_UnmarhsalJSON(t *testing.T) {
+	jsonString := "\"01f3zhkysvcxsnzepyyqtq21fb\""
+
+	subId := &TeamID{}
+
+	err := subId.UnmarhsalJSON([]byte(jsonString))
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhkysvcxsnzepyyqtq21fb", subId.String())
+}
+
+func TestTeamID_MarshalText(t *testing.T) {
+	id := New()
+	subId := TeamIDFromRefID(&id)
+
+	res, err := subId.MarshalText()
+
+	assert.Nil(t, err)
+	assert.Equal(t, []byte(id.String()), res)
+}
+
+func TestTeamID_UnmarshalText(t *testing.T) {
+	text := []byte("01f3zhcaq35403zdjnd6dcm0t2")
+
+	subId := &TeamID{}
+
+	err := subId.UnmarshalText(text)
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhcaq35403zdjnd6dcm0t2", subId.String())
+
+}
+
+func TestTeamID_IsNil(t *testing.T) {
+	subId := TeamID{}
+
+	assert.True(t, subId.IsNil())
+
+	id := New()
+	subId = *TeamIDFromRefID(&id)
+
+	assert.False(t, subId.IsNil())
+}
+
+func TestTeamIDToKeys(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []TeamID
+		expected []string
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]TeamID, 0),
+			expected: make([]string, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []TeamID{MustTeamID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+		},
+		{
+			name: "multiple elements",
+			input: []TeamID{
+				MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustTeamID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustTeamID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, TeamIDToKeys(tc.input))
+		})
+	}
+
+}
+
+func TestTeamIDsFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []string
+		expected struct {
+			res []TeamID
+			err error
+		}
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]string, 0),
+			expected: struct {
+				res []TeamID
+				err error
+			}{
+				res: make([]TeamID, 0),
+				err: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+			expected: struct {
+				res []TeamID
+				err error
+			}{
+				res: []TeamID{MustTeamID("01f3zhcaq35403zdjnd6dcm0t2")},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []TeamID
+				err error
+			}{
+				res: []TeamID{
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []TeamID
+				err error
+			}{
+				res: nil,
+				err: ErrInvalidID,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.expected.err != nil {
+				_, err := TeamIDsFrom(tc.input)
+				assert.True(tt, errors.As(ErrInvalidID, &err))
+			} else {
+				res, err := TeamIDsFrom(tc.input)
+				assert.Equal(tt, tc.expected.res, res)
+				assert.Nil(tt, err)
+			}
+
+		})
+	}
+}
+
+func TestTeamIDsFromID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []ID
+		expected []TeamID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]ID, 0),
+			expected: make([]TeamID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []TeamID{MustTeamID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []TeamID{
+				MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustTeamID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustTeamID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := TeamIDsFromID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestTeamIDsFromIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+
+	testCases := []struct {
+		name     string
+		input    []*ID
+		expected []TeamID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*ID, 0),
+			expected: make([]TeamID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*ID{&id1},
+			expected: []TeamID{MustTeamID(id1.String())},
+		},
+		{
+			name:  "multiple elements",
+			input: []*ID{&id1, &id2, &id3},
+			expected: []TeamID{
+				MustTeamID(id1.String()),
+				MustTeamID(id2.String()),
+				MustTeamID(id3.String()),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := TeamIDsFromIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestTeamIDsToID(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []TeamID
+		expected []ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]TeamID, 0),
+			expected: make([]ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []TeamID{MustTeamID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []TeamID{
+				MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustTeamID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustTeamID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := TeamIDsToID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestTeamIDsToIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	subId1 := MustTeamID(id1.String())
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	subId2 := MustTeamID(id2.String())
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+	subId3 := MustTeamID(id3.String())
+
+	testCases := []struct {
+		name     string
+		input    []*TeamID
+		expected []*ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*TeamID, 0),
+			expected: make([]*ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*TeamID{&subId1},
+			expected: []*ID{&id1},
+		},
+		{
+			name:     "multiple elements",
+			input:    []*TeamID{&subId1, &subId2, &subId3},
+			expected: []*ID{&id1, &id2, &id3},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := TeamIDsToIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestNewTeamIDSet(t *testing.T) {
+	TeamIdSet := NewTeamIDSet()
+
+	assert.NotNil(t, TeamIdSet)
+	assert.Empty(t, TeamIdSet.m)
+	assert.Empty(t, TeamIdSet.s)
+}
+
+func TestTeamIDSet_Add(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []TeamID
+		expected *TeamIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]TeamID, 0),
+			expected: &TeamIDSet{
+				m: map[TeamID]struct{}{},
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []TeamID{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: &TeamIDSet{
+				m: map[TeamID]struct{}{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []TeamID{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []TeamID{
+				MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustTeamID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustTeamID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &TeamIDSet{
+				m: map[TeamID]struct{}{
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []TeamID{
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+		{
+			name: "multiple elements with duplication",
+			input: []TeamID{
+				MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustTeamID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &TeamIDSet{
+				m: map[TeamID]struct{}{
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []TeamID{
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewTeamIDSet()
+			set.Add(tc.input...)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestTeamIDSet_AddRef(t *testing.T) {
+	t.Parallel()
+
+	TeamId := MustTeamID("01f3zhcaq35403zdjnd6dcm0t1")
+
+	testCases := []struct {
+		name     string
+		input    *TeamID
+		expected *TeamIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: nil,
+			expected: &TeamIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: &TeamId,
+			expected: &TeamIDSet{
+				m: map[TeamID]struct{}{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []TeamID{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewTeamIDSet()
+			set.AddRef(tc.input)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestTeamIDSet_Has(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			TeamIDSet
+			TeamID
+		}
+		expected bool
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				TeamIDSet
+				TeamID
+			}{TeamIDSet: TeamIDSet{}, TeamID: MustTeamID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: false,
+		},
+		{
+			name: "Set Contains the element",
+			input: struct {
+				TeamIDSet
+				TeamID
+			}{TeamIDSet: TeamIDSet{
+				m: map[TeamID]struct{}{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []TeamID{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, TeamID: MustTeamID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: true,
+		},
+		{
+			name: "Set does not Contains the element",
+			input: struct {
+				TeamIDSet
+				TeamID
+			}{TeamIDSet: TeamIDSet{
+				m: map[TeamID]struct{}{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []TeamID{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, TeamID: MustTeamID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, tc.input.TeamIDSet.Has(tc.input.TeamID))
+		})
+	}
+}
+
+func TestTeamIDSet_Clear(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    TeamIDSet
+		expected TeamIDSet
+	}{
+		{
+			name:  "Empty Set",
+			input: TeamIDSet{},
+			expected: TeamIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name: "Set Contains the element",
+			input: TeamIDSet{
+				m: map[TeamID]struct{}{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []TeamID{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: TeamIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			set := tc.input
+			p := &set
+			p.Clear()
+			assert.Equal(tt, tc.expected, *p)
+		})
+	}
+}
+
+func TestTeamIDSet_All(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *TeamIDSet
+		expected []TeamID
+	}{
+		{
+			name: "Empty slice",
+			input: &TeamIDSet{
+				m: map[TeamID]struct{}{},
+				s: nil,
+			},
+			expected: make([]TeamID, 0),
+		},
+		{
+			name: "1 element",
+			input: &TeamIDSet{
+				m: map[TeamID]struct{}{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []TeamID{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: []TeamID{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1")},
+		},
+		{
+			name: "multiple elements",
+			input: &TeamIDSet{
+				m: map[TeamID]struct{}{
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []TeamID{
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: []TeamID{
+				MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustTeamID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustTeamID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.All())
+		})
+	}
+}
+
+func TestTeamIDSet_Clone(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *TeamIDSet
+		expected *TeamIDSet
+	}{
+		{
+			name:     "nil set",
+			input:    nil,
+			expected: NewTeamIDSet(),
+		},
+		{
+			name:     "Empty set",
+			input:    NewTeamIDSet(),
+			expected: NewTeamIDSet(),
+		},
+		{
+			name: "1 element",
+			input: &TeamIDSet{
+				m: map[TeamID]struct{}{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []TeamID{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: &TeamIDSet{
+				m: map[TeamID]struct{}{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []TeamID{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: &TeamIDSet{
+				m: map[TeamID]struct{}{
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []TeamID{
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: &TeamIDSet{
+				m: map[TeamID]struct{}{
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []TeamID{
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			clone := tc.input.Clone()
+			assert.Equal(tt, tc.expected, clone)
+			assert.False(tt, tc.input == clone)
+		})
+	}
+}
+
+func TestTeamIDSet_Merge(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			a *TeamIDSet
+			b *TeamIDSet
+		}
+		expected *TeamIDSet
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				a *TeamIDSet
+				b *TeamIDSet
+			}{
+				a: &TeamIDSet{},
+				b: &TeamIDSet{},
+			},
+			expected: &TeamIDSet{},
+		},
+		{
+			name: "1 Empty Set",
+			input: struct {
+				a *TeamIDSet
+				b *TeamIDSet
+			}{
+				a: &TeamIDSet{
+					m: map[TeamID]struct{}{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []TeamID{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &TeamIDSet{},
+			},
+			expected: &TeamIDSet{
+				m: map[TeamID]struct{}{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []TeamID{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "2 non Empty Set",
+			input: struct {
+				a *TeamIDSet
+				b *TeamIDSet
+			}{
+				a: &TeamIDSet{
+					m: map[TeamID]struct{}{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []TeamID{MustTeamID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &TeamIDSet{
+					m: map[TeamID]struct{}{MustTeamID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{}},
+					s: []TeamID{MustTeamID("01f3zhcaq35403zdjnd6dcm0t2")},
+				},
+			},
+			expected: &TeamIDSet{
+				m: map[TeamID]struct{}{
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+				},
+				s: []TeamID{
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustTeamID("01f3zhcaq35403zdjnd6dcm0t2"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.a.Merge(tc.input.b))
+		})
+	}
+}
diff --git a/pkg/id/user_gen_test.go b/pkg/id/user_gen_test.go
new file mode 100644
index 00000000..39394b65
--- /dev/null
+++ b/pkg/id/user_gen_test.go
@@ -0,0 +1,1004 @@
+// Code generated by gen, DO NOT EDIT.
+
+package id
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/oklog/ulid"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewUserID(t *testing.T) {
+	id := NewUserID()
+	assert.NotNil(t, id)
+	ulID, err := ulid.Parse(id.String())
+
+	assert.NotNil(t, ulID)
+	assert.Nil(t, err)
+}
+
+func TestUserIDFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			result UserID
+			err    error
+		}
+	}{
+		{
+			name:  "Fail:Not valid string",
+			input: "testMustFail",
+			expected: struct {
+				result UserID
+				err    error
+			}{
+				UserID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "Fail:Not valid string",
+			input: "",
+			expected: struct {
+				result UserID
+				err    error
+			}{
+				UserID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "success:valid string",
+			input: "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: struct {
+				result UserID
+				err    error
+			}{
+				UserID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+				nil,
+			},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result, err := UserIDFrom(tc.input)
+			assert.Equal(tt, tc.expected.result, result)
+			if err != nil {
+				assert.True(tt, errors.As(tc.expected.err, &err))
+			}
+		})
+	}
+}
+
+func TestMustUserID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name        string
+		input       string
+		shouldPanic bool
+		expected    UserID
+	}{
+		{
+			name:        "Fail:Not valid string",
+			input:       "testMustFail",
+			shouldPanic: true,
+		},
+		{
+			name:        "Fail:Not valid string",
+			input:       "",
+			shouldPanic: true,
+		},
+		{
+			name:        "success:valid string",
+			input:       "01f2r7kg1fvvffp0gmexgy5hxy",
+			shouldPanic: false,
+			expected:    UserID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.shouldPanic {
+				assert.Panics(tt, func() { MustBeID(tc.input) })
+				return
+			}
+			result := MustUserID(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
+
+func TestUserIDFromRef(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected *UserID
+	}{
+		{
+			name:     "Fail:Not valid string",
+			input:    "testMustFail",
+			expected: nil,
+		},
+		{
+			name:     "Fail:Not valid string",
+			input:    "",
+			expected: nil,
+		},
+		{
+			name:     "success:valid string",
+			input:    "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: &UserID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := UserIDFromRef(&tc.input)
+			assert.Equal(tt, tc.expected, result)
+			if tc.expected != nil {
+				assert.Equal(tt, *tc.expected, *result)
+			}
+		})
+	}
+}
+
+func TestUserIDFromRefID(t *testing.T) {
+	id := New()
+
+	subId := UserIDFromRefID(&id)
+
+	assert.NotNil(t, subId)
+	assert.Equal(t, subId.id, id.id)
+}
+
+func TestUserID_ID(t *testing.T) {
+	id := New()
+	subId := UserIDFromRefID(&id)
+
+	idOrg := subId.ID()
+
+	assert.Equal(t, id, idOrg)
+}
+
+func TestUserID_String(t *testing.T) {
+	id := New()
+	subId := UserIDFromRefID(&id)
+
+	assert.Equal(t, subId.String(), id.String())
+}
+
+func TestUserID_GoString(t *testing.T) {
+	id := New()
+	subId := UserIDFromRefID(&id)
+
+	assert.Equal(t, subId.GoString(), "id.UserID("+id.String()+")")
+}
+
+func TestUserID_RefString(t *testing.T) {
+	id := New()
+	subId := UserIDFromRefID(&id)
+
+	refString := subId.StringRef()
+
+	assert.NotNil(t, refString)
+	assert.Equal(t, *refString, id.String())
+}
+
+func TestUserID_Ref(t *testing.T) {
+	id := New()
+	subId := UserIDFromRefID(&id)
+
+	subIdRef := subId.Ref()
+
+	assert.Equal(t, *subId, *subIdRef)
+}
+
+func TestUserID_CopyRef(t *testing.T) {
+	id := New()
+	subId := UserIDFromRefID(&id)
+
+	subIdCopyRef := subId.CopyRef()
+
+	assert.Equal(t, *subId, *subIdCopyRef)
+	assert.False(t, subId == subIdCopyRef)
+}
+
+func TestUserID_IDRef(t *testing.T) {
+	id := New()
+	subId := UserIDFromRefID(&id)
+
+	assert.Equal(t, id, *subId.IDRef())
+}
+
+func TestUserID_StringRef(t *testing.T) {
+	id := New()
+	subId := UserIDFromRefID(&id)
+
+	assert.Equal(t, *subId.StringRef(), id.String())
+}
+
+func TestUserID_MarhsalJSON(t *testing.T) {
+	id := New()
+	subId := UserIDFromRefID(&id)
+
+	res, err := subId.MarhsalJSON()
+	exp, _ := json.Marshal(subId.String())
+
+	assert.Nil(t, err)
+	assert.Equal(t, exp, res)
+}
+
+func TestUserID_UnmarhsalJSON(t *testing.T) {
+	jsonString := "\"01f3zhkysvcxsnzepyyqtq21fb\""
+
+	subId := &UserID{}
+
+	err := subId.UnmarhsalJSON([]byte(jsonString))
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhkysvcxsnzepyyqtq21fb", subId.String())
+}
+
+func TestUserID_MarshalText(t *testing.T) {
+	id := New()
+	subId := UserIDFromRefID(&id)
+
+	res, err := subId.MarshalText()
+
+	assert.Nil(t, err)
+	assert.Equal(t, []byte(id.String()), res)
+}
+
+func TestUserID_UnmarshalText(t *testing.T) {
+	text := []byte("01f3zhcaq35403zdjnd6dcm0t2")
+
+	subId := &UserID{}
+
+	err := subId.UnmarshalText(text)
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhcaq35403zdjnd6dcm0t2", subId.String())
+
+}
+
+func TestUserID_IsNil(t *testing.T) {
+	subId := UserID{}
+
+	assert.True(t, subId.IsNil())
+
+	id := New()
+	subId = *UserIDFromRefID(&id)
+
+	assert.False(t, subId.IsNil())
+}
+
+func TestUserIDToKeys(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []UserID
+		expected []string
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]UserID, 0),
+			expected: make([]string, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []UserID{MustUserID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+		},
+		{
+			name: "multiple elements",
+			input: []UserID{
+				MustUserID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustUserID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustUserID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, UserIDToKeys(tc.input))
+		})
+	}
+
+}
+
+func TestUserIDsFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []string
+		expected struct {
+			res []UserID
+			err error
+		}
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]string, 0),
+			expected: struct {
+				res []UserID
+				err error
+			}{
+				res: make([]UserID, 0),
+				err: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+			expected: struct {
+				res []UserID
+				err error
+			}{
+				res: []UserID{MustUserID("01f3zhcaq35403zdjnd6dcm0t2")},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []UserID
+				err error
+			}{
+				res: []UserID{
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []UserID
+				err error
+			}{
+				res: nil,
+				err: ErrInvalidID,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.expected.err != nil {
+				_, err := UserIDsFrom(tc.input)
+				assert.True(tt, errors.As(ErrInvalidID, &err))
+			} else {
+				res, err := UserIDsFrom(tc.input)
+				assert.Equal(tt, tc.expected.res, res)
+				assert.Nil(tt, err)
+			}
+
+		})
+	}
+}
+
+func TestUserIDsFromID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []ID
+		expected []UserID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]ID, 0),
+			expected: make([]UserID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []UserID{MustUserID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []UserID{
+				MustUserID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustUserID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustUserID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := UserIDsFromID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestUserIDsFromIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+
+	testCases := []struct {
+		name     string
+		input    []*ID
+		expected []UserID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*ID, 0),
+			expected: make([]UserID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*ID{&id1},
+			expected: []UserID{MustUserID(id1.String())},
+		},
+		{
+			name:  "multiple elements",
+			input: []*ID{&id1, &id2, &id3},
+			expected: []UserID{
+				MustUserID(id1.String()),
+				MustUserID(id2.String()),
+				MustUserID(id3.String()),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := UserIDsFromIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestUserIDsToID(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []UserID
+		expected []ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]UserID, 0),
+			expected: make([]ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []UserID{MustUserID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []UserID{
+				MustUserID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustUserID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustUserID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := UserIDsToID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestUserIDsToIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	subId1 := MustUserID(id1.String())
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	subId2 := MustUserID(id2.String())
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+	subId3 := MustUserID(id3.String())
+
+	testCases := []struct {
+		name     string
+		input    []*UserID
+		expected []*ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*UserID, 0),
+			expected: make([]*ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*UserID{&subId1},
+			expected: []*ID{&id1},
+		},
+		{
+			name:     "multiple elements",
+			input:    []*UserID{&subId1, &subId2, &subId3},
+			expected: []*ID{&id1, &id2, &id3},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := UserIDsToIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestNewUserIDSet(t *testing.T) {
+	UserIdSet := NewUserIDSet()
+
+	assert.NotNil(t, UserIdSet)
+	assert.Empty(t, UserIdSet.m)
+	assert.Empty(t, UserIdSet.s)
+}
+
+func TestUserIDSet_Add(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []UserID
+		expected *UserIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]UserID, 0),
+			expected: &UserIDSet{
+				m: map[UserID]struct{}{},
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []UserID{MustUserID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: &UserIDSet{
+				m: map[UserID]struct{}{MustUserID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []UserID{MustUserID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []UserID{
+				MustUserID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustUserID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustUserID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &UserIDSet{
+				m: map[UserID]struct{}{
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []UserID{
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+		{
+			name: "multiple elements with duplication",
+			input: []UserID{
+				MustUserID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustUserID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustUserID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &UserIDSet{
+				m: map[UserID]struct{}{
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []UserID{
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewUserIDSet()
+			set.Add(tc.input...)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestUserIDSet_AddRef(t *testing.T) {
+	t.Parallel()
+
+	UserId := MustUserID("01f3zhcaq35403zdjnd6dcm0t1")
+
+	testCases := []struct {
+		name     string
+		input    *UserID
+		expected *UserIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: nil,
+			expected: &UserIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: &UserId,
+			expected: &UserIDSet{
+				m: map[UserID]struct{}{MustUserID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []UserID{MustUserID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewUserIDSet()
+			set.AddRef(tc.input)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestUserIDSet_Has(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			UserIDSet
+			UserID
+		}
+		expected bool
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				UserIDSet
+				UserID
+			}{UserIDSet: UserIDSet{}, UserID: MustUserID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: false,
+		},
+		{
+			name: "Set Contains the element",
+			input: struct {
+				UserIDSet
+				UserID
+			}{UserIDSet: UserIDSet{
+				m: map[UserID]struct{}{MustUserID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []UserID{MustUserID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, UserID: MustUserID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: true,
+		},
+		{
+			name: "Set does not Contains the element",
+			input: struct {
+				UserIDSet
+				UserID
+			}{UserIDSet: UserIDSet{
+				m: map[UserID]struct{}{MustUserID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []UserID{MustUserID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, UserID: MustUserID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, tc.input.UserIDSet.Has(tc.input.UserID))
+		})
+	}
+}
+
+func TestUserIDSet_Clear(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    UserIDSet
+		expected UserIDSet
+	}{
+		{
+			name:  "Empty Set",
+			input: UserIDSet{},
+			expected: UserIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name: "Set Contains the element",
+			input: UserIDSet{
+				m: map[UserID]struct{}{MustUserID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []UserID{MustUserID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: UserIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			set := tc.input
+			p := &set
+			p.Clear()
+			assert.Equal(tt, tc.expected, *p)
+		})
+	}
+}
+
+func TestUserIDSet_All(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *UserIDSet
+		expected []UserID
+	}{
+		{
+			name: "Empty slice",
+			input: &UserIDSet{
+				m: map[UserID]struct{}{},
+				s: nil,
+			},
+			expected: make([]UserID, 0),
+		},
+		{
+			name: "1 element",
+			input: &UserIDSet{
+				m: map[UserID]struct{}{MustUserID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []UserID{MustUserID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: []UserID{MustUserID("01f3zhcaq35403zdjnd6dcm0t1")},
+		},
+		{
+			name: "multiple elements",
+			input: &UserIDSet{
+				m: map[UserID]struct{}{
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []UserID{
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: []UserID{
+				MustUserID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustUserID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustUserID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.All())
+		})
+	}
+}
+
+func TestUserIDSet_Clone(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *UserIDSet
+		expected *UserIDSet
+	}{
+		{
+			name:     "nil set",
+			input:    nil,
+			expected: NewUserIDSet(),
+		},
+		{
+			name:     "Empty set",
+			input:    NewUserIDSet(),
+			expected: NewUserIDSet(),
+		},
+		{
+			name: "1 element",
+			input: &UserIDSet{
+				m: map[UserID]struct{}{MustUserID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []UserID{MustUserID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: &UserIDSet{
+				m: map[UserID]struct{}{MustUserID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []UserID{MustUserID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: &UserIDSet{
+				m: map[UserID]struct{}{
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []UserID{
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: &UserIDSet{
+				m: map[UserID]struct{}{
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []UserID{
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			clone := tc.input.Clone()
+			assert.Equal(tt, tc.expected, clone)
+			assert.False(tt, tc.input == clone)
+		})
+	}
+}
+
+func TestUserIDSet_Merge(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			a *UserIDSet
+			b *UserIDSet
+		}
+		expected *UserIDSet
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				a *UserIDSet
+				b *UserIDSet
+			}{
+				a: &UserIDSet{},
+				b: &UserIDSet{},
+			},
+			expected: &UserIDSet{},
+		},
+		{
+			name: "1 Empty Set",
+			input: struct {
+				a *UserIDSet
+				b *UserIDSet
+			}{
+				a: &UserIDSet{
+					m: map[UserID]struct{}{MustUserID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []UserID{MustUserID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &UserIDSet{},
+			},
+			expected: &UserIDSet{
+				m: map[UserID]struct{}{MustUserID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []UserID{MustUserID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "2 non Empty Set",
+			input: struct {
+				a *UserIDSet
+				b *UserIDSet
+			}{
+				a: &UserIDSet{
+					m: map[UserID]struct{}{MustUserID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []UserID{MustUserID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &UserIDSet{
+					m: map[UserID]struct{}{MustUserID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{}},
+					s: []UserID{MustUserID("01f3zhcaq35403zdjnd6dcm0t2")},
+				},
+			},
+			expected: &UserIDSet{
+				m: map[UserID]struct{}{
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+				},
+				s: []UserID{
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustUserID("01f3zhcaq35403zdjnd6dcm0t2"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.a.Merge(tc.input.b))
+		})
+	}
+}
diff --git a/pkg/id/widget_gen_test.go b/pkg/id/widget_gen_test.go
new file mode 100644
index 00000000..0a7c65f6
--- /dev/null
+++ b/pkg/id/widget_gen_test.go
@@ -0,0 +1,1004 @@
+// Code generated by gen, DO NOT EDIT.
+
+package id
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/oklog/ulid"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewWidgetID(t *testing.T) {
+	id := NewWidgetID()
+	assert.NotNil(t, id)
+	ulID, err := ulid.Parse(id.String())
+
+	assert.NotNil(t, ulID)
+	assert.Nil(t, err)
+}
+
+func TestWidgetIDFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    string
+		expected struct {
+			result WidgetID
+			err    error
+		}
+	}{
+		{
+			name:  "Fail:Not valid string",
+			input: "testMustFail",
+			expected: struct {
+				result WidgetID
+				err    error
+			}{
+				WidgetID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "Fail:Not valid string",
+			input: "",
+			expected: struct {
+				result WidgetID
+				err    error
+			}{
+				WidgetID{},
+				ErrInvalidID,
+			},
+		},
+		{
+			name:  "success:valid string",
+			input: "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: struct {
+				result WidgetID
+				err    error
+			}{
+				WidgetID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+				nil,
+			},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result, err := WidgetIDFrom(tc.input)
+			assert.Equal(tt, tc.expected.result, result)
+			if err != nil {
+				assert.True(tt, errors.As(tc.expected.err, &err))
+			}
+		})
+	}
+}
+
+func TestMustWidgetID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name        string
+		input       string
+		shouldPanic bool
+		expected    WidgetID
+	}{
+		{
+			name:        "Fail:Not valid string",
+			input:       "testMustFail",
+			shouldPanic: true,
+		},
+		{
+			name:        "Fail:Not valid string",
+			input:       "",
+			shouldPanic: true,
+		},
+		{
+			name:        "success:valid string",
+			input:       "01f2r7kg1fvvffp0gmexgy5hxy",
+			shouldPanic: false,
+			expected:    WidgetID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.shouldPanic {
+				assert.Panics(tt, func() { MustBeID(tc.input) })
+				return
+			}
+			result := MustWidgetID(tc.input)
+			assert.Equal(tt, tc.expected, result)
+		})
+	}
+}
+
+func TestWidgetIDFromRef(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    string
+		expected *WidgetID
+	}{
+		{
+			name:     "Fail:Not valid string",
+			input:    "testMustFail",
+			expected: nil,
+		},
+		{
+			name:     "Fail:Not valid string",
+			input:    "",
+			expected: nil,
+		},
+		{
+			name:     "success:valid string",
+			input:    "01f2r7kg1fvvffp0gmexgy5hxy",
+			expected: &WidgetID{ulid.MustParse("01f2r7kg1fvvffp0gmexgy5hxy")},
+		},
+	}
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			result := WidgetIDFromRef(&tc.input)
+			assert.Equal(tt, tc.expected, result)
+			if tc.expected != nil {
+				assert.Equal(tt, *tc.expected, *result)
+			}
+		})
+	}
+}
+
+func TestWidgetIDFromRefID(t *testing.T) {
+	id := New()
+
+	subId := WidgetIDFromRefID(&id)
+
+	assert.NotNil(t, subId)
+	assert.Equal(t, subId.id, id.id)
+}
+
+func TestWidgetID_ID(t *testing.T) {
+	id := New()
+	subId := WidgetIDFromRefID(&id)
+
+	idOrg := subId.ID()
+
+	assert.Equal(t, id, idOrg)
+}
+
+func TestWidgetID_String(t *testing.T) {
+	id := New()
+	subId := WidgetIDFromRefID(&id)
+
+	assert.Equal(t, subId.String(), id.String())
+}
+
+func TestWidgetID_GoString(t *testing.T) {
+	id := New()
+	subId := WidgetIDFromRefID(&id)
+
+	assert.Equal(t, subId.GoString(), "id.WidgetID("+id.String()+")")
+}
+
+func TestWidgetID_RefString(t *testing.T) {
+	id := New()
+	subId := WidgetIDFromRefID(&id)
+
+	refString := subId.StringRef()
+
+	assert.NotNil(t, refString)
+	assert.Equal(t, *refString, id.String())
+}
+
+func TestWidgetID_Ref(t *testing.T) {
+	id := New()
+	subId := WidgetIDFromRefID(&id)
+
+	subIdRef := subId.Ref()
+
+	assert.Equal(t, *subId, *subIdRef)
+}
+
+func TestWidgetID_CopyRef(t *testing.T) {
+	id := New()
+	subId := WidgetIDFromRefID(&id)
+
+	subIdCopyRef := subId.CopyRef()
+
+	assert.Equal(t, *subId, *subIdCopyRef)
+	assert.NotSame(t, subId, subIdCopyRef)
+}
+
+func TestWidgetID_IDRef(t *testing.T) {
+	id := New()
+	subId := WidgetIDFromRefID(&id)
+
+	assert.Equal(t, id, *subId.IDRef())
+}
+
+func TestWidgetID_StringRef(t *testing.T) {
+	id := New()
+	subId := WidgetIDFromRefID(&id)
+
+	assert.Equal(t, *subId.StringRef(), id.String())
+}
+
+func TestWidgetID_MarhsalJSON(t *testing.T) {
+	id := New()
+	subId := WidgetIDFromRefID(&id)
+
+	res, err := subId.MarhsalJSON()
+	exp, _ := json.Marshal(subId.String())
+
+	assert.Nil(t, err)
+	assert.Equal(t, exp, res)
+}
+
+func TestWidgetID_UnmarhsalJSON(t *testing.T) {
+	jsonString := "\"01f3zhkysvcxsnzepyyqtq21fb\""
+
+	subId := &WidgetID{}
+
+	err := subId.UnmarhsalJSON([]byte(jsonString))
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhkysvcxsnzepyyqtq21fb", subId.String())
+}
+
+func TestWidgetID_MarshalText(t *testing.T) {
+	id := New()
+	subId := WidgetIDFromRefID(&id)
+
+	res, err := subId.MarshalText()
+
+	assert.Nil(t, err)
+	assert.Equal(t, []byte(id.String()), res)
+}
+
+func TestWidgetID_UnmarshalText(t *testing.T) {
+	text := []byte("01f3zhcaq35403zdjnd6dcm0t2")
+
+	subId := &WidgetID{}
+
+	err := subId.UnmarshalText(text)
+
+	assert.Nil(t, err)
+	assert.Equal(t, "01f3zhcaq35403zdjnd6dcm0t2", subId.String())
+
+}
+
+func TestWidgetID_IsNil(t *testing.T) {
+	subId := WidgetID{}
+
+	assert.True(t, subId.IsNil())
+
+	id := New()
+	subId = *WidgetIDFromRefID(&id)
+
+	assert.False(t, subId.IsNil())
+}
+
+func TestWidgetIDToKeys(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []WidgetID
+		expected []string
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]WidgetID, 0),
+			expected: make([]string, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []WidgetID{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+		},
+		{
+			name: "multiple elements",
+			input: []WidgetID{
+				MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustWidgetID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, WidgetIDToKeys(tc.input))
+		})
+	}
+
+}
+
+func TestWidgetIDsFrom(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []string
+		expected struct {
+			res []WidgetID
+			err error
+		}
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]string, 0),
+			expected: struct {
+				res []WidgetID
+				err error
+			}{
+				res: make([]WidgetID, 0),
+				err: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []string{"01f3zhcaq35403zdjnd6dcm0t2"},
+			expected: struct {
+				res []WidgetID
+				err error
+			}{
+				res: []WidgetID{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2")},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []WidgetID
+				err error
+			}{
+				res: []WidgetID{
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+				err: nil,
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []string{
+				"01f3zhcaq35403zdjnd6dcm0t1",
+				"01f3zhcaq35403zdjnd6dcm0t2",
+				"01f3zhcaq35403zdjnd6dcm0t3",
+			},
+			expected: struct {
+				res []WidgetID
+				err error
+			}{
+				res: nil,
+				err: ErrInvalidID,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			if tc.expected.err != nil {
+				_, err := WidgetIDsFrom(tc.input)
+				assert.True(tt, errors.As(ErrInvalidID, &err))
+			} else {
+				res, err := WidgetIDsFrom(tc.input)
+				assert.Equal(tt, tc.expected.res, res)
+				assert.Nil(tt, err)
+			}
+
+		})
+	}
+}
+
+func TestWidgetIDsFromID(t *testing.T) {
+	t.Parallel()
+	testCases := []struct {
+		name     string
+		input    []ID
+		expected []WidgetID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]ID, 0),
+			expected: make([]WidgetID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []WidgetID{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []WidgetID{
+				MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustWidgetID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := WidgetIDsFromID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestWidgetIDsFromIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+
+	testCases := []struct {
+		name     string
+		input    []*ID
+		expected []WidgetID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*ID, 0),
+			expected: make([]WidgetID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*ID{&id1},
+			expected: []WidgetID{MustWidgetID(id1.String())},
+		},
+		{
+			name:  "multiple elements",
+			input: []*ID{&id1, &id2, &id3},
+			expected: []WidgetID{
+				MustWidgetID(id1.String()),
+				MustWidgetID(id2.String()),
+				MustWidgetID(id3.String()),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := WidgetIDsFromIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestWidgetIDsToID(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []WidgetID
+		expected []ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]WidgetID, 0),
+			expected: make([]ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []WidgetID{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: []ID{MustBeID("01f3zhcaq35403zdjnd6dcm0t2")},
+		},
+		{
+			name: "multiple elements",
+			input: []WidgetID{
+				MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustWidgetID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: []ID{
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustBeID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := WidgetIDsToID(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestWidgetIDsToIDRef(t *testing.T) {
+	t.Parallel()
+
+	id1 := MustBeID("01f3zhcaq35403zdjnd6dcm0t1")
+	subId1 := MustWidgetID(id1.String())
+	id2 := MustBeID("01f3zhcaq35403zdjnd6dcm0t2")
+	subId2 := MustWidgetID(id2.String())
+	id3 := MustBeID("01f3zhcaq35403zdjnd6dcm0t3")
+	subId3 := MustWidgetID(id3.String())
+
+	testCases := []struct {
+		name     string
+		input    []*WidgetID
+		expected []*ID
+	}{
+		{
+			name:     "Empty slice",
+			input:    make([]*WidgetID, 0),
+			expected: make([]*ID, 0),
+		},
+		{
+			name:     "1 element",
+			input:    []*WidgetID{&subId1},
+			expected: []*ID{&id1},
+		},
+		{
+			name:     "multiple elements",
+			input:    []*WidgetID{&subId1, &subId2, &subId3},
+			expected: []*ID{&id1, &id2, &id3},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			res := WidgetIDsToIDRef(tc.input)
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestNewWidgetIDSet(t *testing.T) {
+	WidgetIdSet := NewWidgetIDSet()
+
+	assert.NotNil(t, WidgetIdSet)
+	assert.Empty(t, WidgetIdSet.m)
+	assert.Empty(t, WidgetIdSet.s)
+}
+
+func TestWidgetIDSet_Add(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    []WidgetID
+		expected *WidgetIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: make([]WidgetID, 0),
+			expected: &WidgetIDSet{
+				m: map[WidgetID]struct{}{},
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: []WidgetID{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: &WidgetIDSet{
+				m: map[WidgetID]struct{}{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []WidgetID{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: []WidgetID{
+				MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustWidgetID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &WidgetIDSet{
+				m: map[WidgetID]struct{}{
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []WidgetID{
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+		{
+			name: "multiple elements with duplication",
+			input: []WidgetID{
+				MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustWidgetID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+			expected: &WidgetIDSet{
+				m: map[WidgetID]struct{}{
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []WidgetID{
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewWidgetIDSet()
+			set.Add(tc.input...)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestWidgetIDSet_AddRef(t *testing.T) {
+	t.Parallel()
+
+	WidgetId := MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1")
+
+	testCases := []struct {
+		name     string
+		input    *WidgetID
+		expected *WidgetIDSet
+	}{
+		{
+			name:  "Empty slice",
+			input: nil,
+			expected: &WidgetIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name:  "1 element",
+			input: &WidgetId,
+			expected: &WidgetIDSet{
+				m: map[WidgetID]struct{}{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []WidgetID{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			set := NewWidgetIDSet()
+			set.AddRef(tc.input)
+			assert.Equal(tt, tc.expected, set)
+		})
+	}
+}
+
+func TestWidgetIDSet_Has(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			WidgetIDSet
+			WidgetID
+		}
+		expected bool
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				WidgetIDSet
+				WidgetID
+			}{WidgetIDSet: WidgetIDSet{}, WidgetID: MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: false,
+		},
+		{
+			name: "Set Contains the element",
+			input: struct {
+				WidgetIDSet
+				WidgetID
+			}{WidgetIDSet: WidgetIDSet{
+				m: map[WidgetID]struct{}{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []WidgetID{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, WidgetID: MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			expected: true,
+		},
+		{
+			name: "Set does not Contains the element",
+			input: struct {
+				WidgetIDSet
+				WidgetID
+			}{WidgetIDSet: WidgetIDSet{
+				m: map[WidgetID]struct{}{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []WidgetID{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			}, WidgetID: MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2")},
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			assert.Equal(tt, tc.expected, tc.input.WidgetIDSet.Has(tc.input.WidgetID))
+		})
+	}
+}
+
+func TestWidgetIDSet_Clear(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    WidgetIDSet
+		expected WidgetIDSet
+	}{
+		{
+			name:  "Empty Set",
+			input: WidgetIDSet{},
+			expected: WidgetIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+		{
+			name: "Set Contains the element",
+			input: WidgetIDSet{
+				m: map[WidgetID]struct{}{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []WidgetID{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: WidgetIDSet{
+				m: nil,
+				s: nil,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			set := tc.input
+			p := &set
+			p.Clear()
+			assert.Equal(tt, tc.expected, *p)
+		})
+	}
+}
+
+func TestWidgetIDSet_All(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *WidgetIDSet
+		expected []WidgetID
+	}{
+		{
+			name: "Empty slice",
+			input: &WidgetIDSet{
+				m: map[WidgetID]struct{}{},
+				s: nil,
+			},
+			expected: make([]WidgetID, 0),
+		},
+		{
+			name: "1 element",
+			input: &WidgetIDSet{
+				m: map[WidgetID]struct{}{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []WidgetID{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: []WidgetID{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1")},
+		},
+		{
+			name: "multiple elements",
+			input: &WidgetIDSet{
+				m: map[WidgetID]struct{}{
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []WidgetID{
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: []WidgetID{
+				MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"),
+				MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2"),
+				MustWidgetID("01f3zhcaq35403zdjnd6dcm0t3"),
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.All())
+		})
+	}
+}
+
+func TestWidgetIDSet_Clone(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    *WidgetIDSet
+		expected *WidgetIDSet
+	}{
+		{
+			name:     "nil set",
+			input:    nil,
+			expected: NewWidgetIDSet(),
+		},
+		{
+			name:     "Empty set",
+			input:    NewWidgetIDSet(),
+			expected: NewWidgetIDSet(),
+		},
+		{
+			name: "1 element",
+			input: &WidgetIDSet{
+				m: map[WidgetID]struct{}{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []WidgetID{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+			expected: &WidgetIDSet{
+				m: map[WidgetID]struct{}{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []WidgetID{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "multiple elements",
+			input: &WidgetIDSet{
+				m: map[WidgetID]struct{}{
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []WidgetID{
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+			expected: &WidgetIDSet{
+				m: map[WidgetID]struct{}{
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t3"): struct{}{},
+				},
+				s: []WidgetID{
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2"),
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t3"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			clone := tc.input.Clone()
+			assert.Equal(tt, tc.expected, clone)
+			assert.False(tt, tc.input == clone)
+		})
+	}
+}
+
+func TestWidgetIDSet_Merge(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name  string
+		input struct {
+			a *WidgetIDSet
+			b *WidgetIDSet
+		}
+		expected *WidgetIDSet
+	}{
+		{
+			name: "Empty Set",
+			input: struct {
+				a *WidgetIDSet
+				b *WidgetIDSet
+			}{
+				a: &WidgetIDSet{},
+				b: &WidgetIDSet{},
+			},
+			expected: &WidgetIDSet{},
+		},
+		{
+			name: "1 Empty Set",
+			input: struct {
+				a *WidgetIDSet
+				b *WidgetIDSet
+			}{
+				a: &WidgetIDSet{
+					m: map[WidgetID]struct{}{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []WidgetID{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &WidgetIDSet{},
+			},
+			expected: &WidgetIDSet{
+				m: map[WidgetID]struct{}{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+				s: []WidgetID{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1")},
+			},
+		},
+		{
+			name: "2 non Empty Set",
+			input: struct {
+				a *WidgetIDSet
+				b *WidgetIDSet
+			}{
+				a: &WidgetIDSet{
+					m: map[WidgetID]struct{}{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{}},
+					s: []WidgetID{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1")},
+				},
+				b: &WidgetIDSet{
+					m: map[WidgetID]struct{}{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{}},
+					s: []WidgetID{MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2")},
+				},
+			},
+			expected: &WidgetIDSet{
+				m: map[WidgetID]struct{}{
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"): struct{}{},
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2"): struct{}{},
+				},
+				s: []WidgetID{
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t1"),
+					MustWidgetID("01f3zhcaq35403zdjnd6dcm0t2"),
+				},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+
+			assert.Equal(tt, tc.expected, tc.input.a.Merge(tc.input.b))
+		})
+	}
+}
diff --git a/pkg/layer/merging/merger.go b/pkg/layer/merging/merger.go
index 0c59a42d..c2991971 100644
--- a/pkg/layer/merging/merger.go
+++ b/pkg/layer/merging/merger.go
@@ -38,7 +38,7 @@ func (m *Merger) MergeLayer(ctx context.Context, l layer.Layer, parent *layer.Gr
 
 		children := make([]MergedLayer, 0, len(layers))
 		for _, c := range layers {
-			if c == nil {
+			if c == nil || !(*c).IsVisible() {
 				continue
 			}
 			ml, err := m.MergeLayer(ctx, *c, lg)
diff --git a/pkg/plugin/manifest/schema_gen.go b/pkg/plugin/manifest/schema_gen.go
index 815a1567..cc5c899e 100644
--- a/pkg/plugin/manifest/schema_gen.go
+++ b/pkg/plugin/manifest/schema_gen.go
@@ -1,6 +1,6 @@
 package manifest
 
-// generated by "/var/folders/qf/bs41lxts47s6y_d62bj5zgym0000gn/T/go-build906758225/b001/exe/schematyper -o schema_gen.go --package manifest ../../../plugin_manifest_schema.json" -- DO NOT EDIT
+// generated by "/var/folders/lz/nhqy382n28g31wb4f_40gbmc0000gp/T/go-build3669425617/b001/exe/schematyper -o schema_gen.go --package manifest ../../../plugin_manifest_schema.json" -- DO NOT EDIT
 
 type Choice struct {
 	Icon  string `json:"icon,omitempty"`
diff --git a/pkg/project/builder.go b/pkg/project/builder.go
index 76a6b996..1891ed2e 100644
--- a/pkg/project/builder.go
+++ b/pkg/project/builder.go
@@ -52,6 +52,21 @@ func (b *Builder) IsArchived(isArchived bool) *Builder {
 	return b
 }
 
+func (b *Builder) IsBasicAuthActive(isBasicAuthActive bool) *Builder {
+	b.p.isBasicAuthActive = isBasicAuthActive
+	return b
+}
+
+func (b *Builder) BasicAuthUsername(basicAuthUsername string) *Builder {
+	b.p.basicAuthUsername = basicAuthUsername
+	return b
+}
+
+func (b *Builder) BasicAuthPassword(basicAuthPassword string) *Builder {
+	b.p.basicAuthPassword = basicAuthPassword
+	return b
+}
+
 func (b *Builder) UpdatedAt(updatedAt time.Time) *Builder {
 	b.p.updatedAt = updatedAt
 	return b
diff --git a/pkg/project/builder_test.go b/pkg/project/builder_test.go
index 0a6d5d82..09bbdf47 100644
--- a/pkg/project/builder_test.go
+++ b/pkg/project/builder_test.go
@@ -53,6 +53,17 @@ func TestBuilder_IsArchived(t *testing.T) {
 	assert.True(t, res.IsArchived())
 }
 
+func TestBuilder_BasicAuthUsername(t *testing.T) {
+	var tb = New().NewID()
+	res := tb.BasicAuthUsername("username").MustBuild()
+	assert.Equal(t, "username", res.BasicAuthUsername())
+}
+func TestBuilder_BasicAuthPassword(t *testing.T) {
+	var tb = New().NewID()
+	res := tb.BasicAuthPassword("password").MustBuild()
+	assert.Equal(t, "password", res.BasicAuthPassword())
+}
+
 func TestBuilder_ImageURL(t *testing.T) {
 	testCases := []struct {
 		name        string
diff --git a/pkg/project/project.go b/pkg/project/project.go
index bebfa06c..c15f9f55 100644
--- a/pkg/project/project.go
+++ b/pkg/project/project.go
@@ -19,6 +19,9 @@ var (
 type Project struct {
 	id                id.ProjectID
 	isArchived        bool
+	isBasicAuthActive bool
+	basicAuthUsername string
+	basicAuthPassword string
 	updatedAt         time.Time
 	publishedAt       time.Time
 	name              string
@@ -42,6 +45,18 @@ func (p *Project) IsArchived() bool {
 	return p.isArchived
 }
 
+func (p *Project) IsBasicAuthActive() bool {
+	return p.isBasicAuthActive
+}
+
+func (p *Project) BasicAuthUsername() string {
+	return p.basicAuthUsername
+}
+
+func (p *Project) BasicAuthPassword() string {
+	return p.basicAuthPassword
+}
+
 func (p *Project) UpdatedAt() time.Time {
 	return p.updatedAt
 }
@@ -106,6 +121,18 @@ func (p *Project) SetArchived(isArchived bool) {
 	p.isArchived = isArchived
 }
 
+func (p *Project) SetIsBasicAuthActive(isBasicAuthActive bool) {
+	p.isBasicAuthActive = isBasicAuthActive
+}
+
+func (p *Project) SetBasicAuthUsername(basicAuthUsername string) {
+	p.basicAuthUsername = basicAuthUsername
+}
+
+func (p *Project) SetBasicAuthPassword(basicAuthPassword string) {
+	p.basicAuthPassword = basicAuthPassword
+}
+
 func (p *Project) SetUpdatedAt(updatedAt time.Time) {
 	p.updatedAt = updatedAt
 }
diff --git a/pkg/project/project_test.go b/pkg/project/project_test.go
index adc6dc9e..15255f7f 100644
--- a/pkg/project/project_test.go
+++ b/pkg/project/project_test.go
@@ -268,3 +268,67 @@ func TestProject_PublicName(t *testing.T) {
 		})
 	}
 }
+
+func TestProject_IsBasicAuthActive(t *testing.T) {
+	tests := []struct {
+		name     string
+		p        *Project
+		expected bool
+	}{
+		{
+			name: "basic auth is inactive",
+			p: &Project{
+				isBasicAuthActive: false,
+			},
+			expected: false,
+		},
+		{
+			name: "basic auth is active",
+			p: &Project{
+				isBasicAuthActive: true,
+			},
+			expected: true,
+		},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(tt *testing.T) {
+			tt.Parallel()
+			res := tc.p.IsBasicAuthActive()
+			assert.Equal(tt, tc.expected, res)
+		})
+	}
+}
+
+func TestProject_BasicAuthUsername(t *testing.T) {
+	t.Run("return basic auth username", func(t *testing.T) {
+		p := &Project{basicAuthUsername: "test1"}
+		res := p.BasicAuthUsername()
+		assert.Equal(t, "test1", res)
+	})
+}
+
+func TestProject_BasicAuthPassword(t *testing.T) {
+	t.Run("return basic auth password", func(t *testing.T) {
+		p := &Project{basicAuthPassword: "password"}
+		res := p.BasicAuthPassword()
+		assert.Equal(t, "password", res)
+	})
+}
+
+func TestProject_SetIsBasicAuthActive(t *testing.T) {
+	p := &Project{}
+	p.SetIsBasicAuthActive(true)
+	assert.Equal(t, true, p.isBasicAuthActive)
+}
+
+func TestProject_SetBasicAuthUsername(t *testing.T) {
+	p := &Project{}
+	p.SetBasicAuthUsername("username")
+	assert.Equal(t, "username", p.basicAuthUsername)
+}
+
+func TestProject_SetBasicAuthPassword(t *testing.T) {
+	p := &Project{}
+	p.SetBasicAuthPassword("password")
+	assert.Equal(t, "password", p.basicAuthPassword)
+}
diff --git a/schema.graphql b/schema.graphql
index 7d1acd0b..1b72a5b0 100644
--- a/schema.graphql
+++ b/schema.graphql
@@ -180,6 +180,9 @@ enum Role {
 type Project implements Node {
     id: ID!
     isArchived: Boolean!
+    isBasicAuthActive: Boolean!
+    basicAuthUsername: String!
+    basicAuthPassword: String!
     createdAt: DateTime!
     updatedAt: DateTime!
     publishedAt: DateTime
@@ -738,6 +741,9 @@ input UpdateProjectInput {
     name: String
     description: String
     archived: Boolean
+    isBasicAuthActive: Boolean
+    basicAuthUsername: String
+    basicAuthPassword: String
     alias: String
     imageUrl: URL
     publicTitle: String