feat: auto generated files and new structure (#4)

## Description  relates to #1234 ## Checklist - [ ] Issue was linked above - [ ] Code format was applied: `make fmt` - [ ] Examples were added / adjusted (see `examples/` directory) - [x] Docs are up-to-date: `make generate-docs` (will be checked by CI) - [ ] Unit tests got implemented or updated - [ ] Acceptance tests got implemented or updated (see e.g. [here](f5f99d1709/stackit/internal/services/dns/dns_acc_test.go)) - [x] Unit tests are passing: `make test` (will be checked by CI) - [x] No linter issues: `make lint` (will be checked by CI) Reviewed-on: #4 Reviewed-by: Andre_Harms <andre.harms@stackit.cloud> Co-authored-by: Marcel S. Henselin <marcel.henselin@stackit.cloud> Co-committed-by: Marcel S. Henselin <marcel.henselin@stackit.cloud>
2026-01-29 14:10:25 +00:00 · 2026-01-29 14:10:25 +00:00 · 9f41c4da7f
commit 9f41c4da7f
parent 979220be66
1283 changed files with 273211 additions and 4614 deletions
--- a/stackit/internal/services/postgresflexalpha/database/datasources_gen/databases_data_source_gen.go
+++ b/stackit/internal/services/postgresflexalpha/database/datasources_gen/databases_data_source_gen.go
--- a/stackit/internal/services/postgresflexalpha/database/resources_gen/database_resource_gen.go
+++ b/stackit/internal/services/postgresflexalpha/database/resources_gen/database_resource_gen.go
@ -0,0 +1,39 @@
+// Code generated by terraform-plugin-framework-generator DO NOT EDIT.
+
+package postgresflexalpha
+
+import (
+	"context"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema"
+)
+
+func DatabaseResourceSchema(ctx context.Context) schema.Schema {
+	return schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"id": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "The id of the database.",
+				MarkdownDescription: "The id of the database.",
+			},
+			"name": schema.StringAttribute{
+				Required:            true,
+				Description:         "The name of the database.",
+				MarkdownDescription: "The name of the database.",
+			},
+			"owner": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The owner of the database.",
+				MarkdownDescription: "The owner of the database.",
+			},
+		},
+	}
+}
+
+type DatabaseModel struct {
+	Id    types.Int64  `tfsdk:"id"`
+	Name  types.String `tfsdk:"name"`
+	Owner types.String `tfsdk:"owner"`
+}
--- a/stackit/internal/services/postgresflexalpha/flavor/datasource.go
+++ b/stackit/internal/services/postgresflexalpha/flavor/datasource.go
@ -10,7 +10,7 @@ import (
 	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
 	"github.com/mhenselin/terraform-provider-stackitprivatepreview/pkg/postgresflexalpha"
 	"github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/conversion"
-	postgresflex "github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha"
+	postgresflexalphaGen "github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/flavors/datasources_gen"
 	postgresflexUtils "github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/utils"
 	"github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/utils"

@ -143,9 +143,9 @@ func (r *flavorDataSource) Schema(ctx context.Context, _ datasource.SchemaReques
 							Computed: true,
 						},
 					},
-					CustomType: postgresflex.StorageClassesType{
+					CustomType: postgresflexalphaGen.StorageClassesType{
 						ObjectType: types.ObjectType{
-							AttrTypes: postgresflex.StorageClassesValue{}.AttributeTypes(ctx),
+							AttrTypes: postgresflexalphaGen.StorageClassesValue{}.AttributeTypes(ctx),
 						},
 					},
 				},
@ -210,9 +210,9 @@ func (r *flavorDataSource) Read(ctx context.Context, req datasource.ReadRequest,
 	model.MinGb = types.Int64Value(*f.MinGB)

 	if f.StorageClasses == nil {
-		model.StorageClasses = types.ListNull(postgresflex.StorageClassesType{
+		model.StorageClasses = types.ListNull(postgresflexalphaGen.StorageClassesType{
 			ObjectType: basetypes.ObjectType{
-				AttrTypes: postgresflex.StorageClassesValue{}.AttributeTypes(ctx),
+				AttrTypes: postgresflexalphaGen.StorageClassesValue{}.AttributeTypes(ctx),
 			},
 		})
 	} else {
@ -220,8 +220,8 @@ func (r *flavorDataSource) Read(ctx context.Context, req datasource.ReadRequest,
 		for _, sc := range *f.StorageClasses {
 			scList = append(
 				scList,
-				postgresflex.NewStorageClassesValueMust(
-					postgresflex.StorageClassesValue{}.AttributeTypes(ctx),
+				postgresflexalphaGen.NewStorageClassesValueMust(
+					postgresflexalphaGen.StorageClassesValue{}.AttributeTypes(ctx),
 					map[string]attr.Value{
 						"class":             types.StringValue(*sc.Class),
 						"max_io_per_sec":    types.Int64Value(*sc.MaxIoPerSec),
@ -231,9 +231,9 @@ func (r *flavorDataSource) Read(ctx context.Context, req datasource.ReadRequest,
 			)
 		}
 		storageClassesList := types.ListValueMust(
-			postgresflex.StorageClassesType{
+			postgresflexalphaGen.StorageClassesType{
 				ObjectType: basetypes.ObjectType{
-					AttrTypes: postgresflex.StorageClassesValue{}.AttributeTypes(ctx),
+					AttrTypes: postgresflexalphaGen.StorageClassesValue{}.AttributeTypes(ctx),
 				},
 			},
 			scList,
--- a/stackit/internal/services/postgresflexalpha/flavor/datasources_gen/flavors_data_source_gen.go
+++ b/stackit/internal/services/postgresflexalpha/flavor/datasources_gen/flavors_data_source_gen.go
@ -1,12 +1,10 @@
 // Code generated by terraform-plugin-framework-generator DO NOT EDIT.

-package postgresflex
+package postgresflexalpha

 import (
 	"context"
 	"fmt"
-	"strings"
-
 	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
 	"github.com/hashicorp/terraform-plugin-framework/attr"
 	"github.com/hashicorp/terraform-plugin-framework/diag"
@ -14,42 +12,18 @@ import (
 	"github.com/hashicorp/terraform-plugin-framework/types"
 	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
 	"github.com/hashicorp/terraform-plugin-go/tftypes"
+	"strings"

 	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
 )

-func FlavorDataSourceSchema(ctx context.Context) schema.Schema {
+func FlavorsDataSourceSchema(ctx context.Context) schema.Schema {
 	return schema.Schema{
 		Attributes: map[string]schema.Attribute{
-			"cpu": schema.Int64Attribute{
-				Optional: true,
-				Computed: true,
-				//Description:         "The cpu count of the instance.",
-				//MarkdownDescription: "The cpu count of the instance.",
-			},
-			"ram": schema.Int64Attribute{
-				Optional: true,
-				Computed: true,
-				//Description:         "The cpu count of the instance.",
-				//MarkdownDescription: "The cpu count of the instance.",
-			},
-			"node_type": schema.StringAttribute{
-				Optional: true,
-				Computed: true,
-				//Description:         "The cpu count of the instance.",
-				//MarkdownDescription: "The cpu count of the instance.",
-			},
-			"storage_class": schema.StringAttribute{
-				Optional: true,
-				Computed: true,
-				//Description:         "The cpu count of the instance.",
-				//MarkdownDescription: "The cpu count of the instance.",
-			},
 			"flavors": schema.ListNestedAttribute{
 				NestedObject: schema.NestedAttributeObject{
 					Attributes: map[string]schema.Attribute{
 						"cpu": schema.Int64Attribute{
-							Optional:            true,
 							Computed:            true,
 							Description:         "The cpu count of the instance.",
 							MarkdownDescription: "The cpu count of the instance.",
@ -70,7 +44,6 @@ func FlavorDataSourceSchema(ctx context.Context) schema.Schema {
 							MarkdownDescription: "maximum storage which can be ordered for the flavor in Gigabyte.",
 						},
 						"memory": schema.Int64Attribute{
-							Optional:            true,
 							Computed:            true,
 							Description:         "The memory of the instance in Gibibyte.",
 							MarkdownDescription: "The memory of the instance in Gibibyte.",
@ -81,7 +54,6 @@ func FlavorDataSourceSchema(ctx context.Context) schema.Schema {
 							MarkdownDescription: "minimum storage which is required to order in Gigabyte.",
 						},
 						"node_type": schema.StringAttribute{
-							Optional:            true,
 							Computed:            true,
 							Description:         "defines the nodeType it can be either single or replica",
 							MarkdownDescription: "defines the nodeType it can be either single or replica",
@ -205,9 +177,6 @@ func FlavorDataSourceSchema(ctx context.Context) schema.Schema {
 }

 type FlavorsModel struct {
-	Cpu        types.Int64     `tfsdk:"cpu"`
-	Ram        types.Int64     `tfsdk:"ram"`
-	NodeType   types.String    `tfsdk:"node_type"`
 	Flavors    types.List      `tfsdk:"flavors"`
 	Page       types.Int64     `tfsdk:"page"`
 	Pagination PaginationValue `tfsdk:"pagination"`
--- a/stackit/internal/services/postgresflexalpha/flavors/datasource.go
+++ b/stackit/internal/services/postgresflexalpha/flavors/datasource.go
@ -0,0 +1,70 @@
+package postgresflexalpha
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource"
+	"github.com/hashicorp/terraform-plugin-log/tflog"
+	"github.com/mhenselin/terraform-provider-stackitprivatepreview/pkg/postgresflexalpha"
+	"github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/conversion"
+	"github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/core"
+	postgresflexalphaGen "github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/flavors/datasources_gen"
+	postgresflexUtils "github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/utils"
+)
+
+var (
+	_ datasource.DataSource              = &flavorsDataSource{}
+	_ datasource.DataSourceWithConfigure = &flavorsDataSource{}
+)
+
+func NewFlavorsDataSource() datasource.DataSource {
+	return &flavorsDataSource{}
+}
+
+type flavorsDataSource struct {
+	client       *postgresflexalpha.APIClient
+	providerData core.ProviderData
+}
+
+func (d *flavorsDataSource) Metadata(_ context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
+	resp.TypeName = req.ProviderTypeName + "_postgresflexalpha_flavors"
+}
+
+func (d *flavorsDataSource) Schema(ctx context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	resp.Schema = postgresflexalphaGen.FlavorsDataSourceSchema(ctx)
+}
+
+// Configure adds the provider configured client to the data source.
+func (d *flavorsDataSource) Configure(ctx context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {
+	var ok bool
+	d.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
+	if !ok {
+		return
+	}
+
+	apiClient := postgresflexUtils.ConfigureClient(ctx, &d.providerData, &resp.Diagnostics)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	d.client = apiClient
+	tflog.Info(ctx, "Postgres Flex version client configured")
+}
+
+func (d *flavorsDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) {
+	var data postgresflexalphaGen.FlavorsModel
+
+	// Read Terraform configuration data into the model
+	resp.Diagnostics.Append(req.Config.Get(ctx, &data)...)
+
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	// Todo: Read API call logic
+
+	// Example data value setting
+	// data.Id = types.StringValue("example-id")
+
+	// Save data into Terraform state
+	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
+}
--- a/stackit/internal/services/postgresflexalpha/flavors/datasources_gen/flavors_data_source_gen.go
+++ b/stackit/internal/services/postgresflexalpha/flavors/datasources_gen/flavors_data_source_gen.go
--- a/stackit/internal/services/postgresflexalpha/instance/datasource.go
+++ b/stackit/internal/services/postgresflexalpha/instance/datasource.go
@ -7,18 +7,13 @@ import (

 	"github.com/mhenselin/terraform-provider-stackitprivatepreview/pkg/postgresflexalpha"
 	"github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/conversion"
+	postgresflexalpha2 "github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/instance/datasources_gen"
 	postgresflexUtils "github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/utils"

 	"github.com/hashicorp/terraform-plugin-framework/datasource"
-	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
-	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
 	"github.com/hashicorp/terraform-plugin-log/tflog"
 	"github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/core"
 	"github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/utils"
-	"github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/validate"
-
-	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
-	"github.com/hashicorp/terraform-plugin-framework/types"
 )

 // Ensure the implementation satisfies the expected interfaces.
@ -38,20 +33,12 @@ type instanceDataSource struct {
 }

 // Metadata returns the data source type name.
-func (r *instanceDataSource) Metadata(
-	_ context.Context,
-	req datasource.MetadataRequest,
-	resp *datasource.MetadataResponse,
-) {
+func (r *instanceDataSource) Metadata(_ context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
 	resp.TypeName = req.ProviderTypeName + "_postgresflexalpha_instance"
 }

 // Configure adds the provider configured client to the data source.
-func (r *instanceDataSource) Configure(
-	ctx context.Context,
-	req datasource.ConfigureRequest,
-	resp *datasource.ConfigureResponse,
-) {
+func (r *instanceDataSource) Configure(ctx context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {
 	var ok bool
 	r.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
 	if !ok {
@ -67,131 +54,13 @@ func (r *instanceDataSource) Configure(
 }

 // Schema defines the schema for the data source.
-func (r *instanceDataSource) Schema(_ context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
-	descriptions := map[string]string{
-		"main":        "Postgres Flex instance data source schema. Must have a `region` specified in the provider configuration.",
-		"id":          "Terraform's internal data source. ID. It is structured as \"`project_id`,`region`,`instance_id`\".",
-		"instance_id": "ID of the PostgresFlex instance.",
-		"project_id":  "STACKIT project ID to which the instance is associated.",
-		"name":        "Instance name.",
-		"acl":         "The Access Control List (ACL) for the PostgresFlex instance.",
-		"region":      "The resource region. If not defined, the provider region is used.",
-	}
-
-	resp.Schema = schema.Schema{
-		Description: descriptions["main"],
-		Attributes: map[string]schema.Attribute{
-			"id": schema.StringAttribute{
-				Description: descriptions["id"],
-				Computed:    true,
-			},
-			"instance_id": schema.StringAttribute{
-				Description: descriptions["instance_id"],
-				Required:    true,
-				Validators: []validator.String{
-					validate.UUID(),
-					validate.NoSeparator(),
-				},
-			},
-			"project_id": schema.StringAttribute{
-				Description: descriptions["project_id"],
-				Required:    true,
-				Validators: []validator.String{
-					validate.UUID(),
-					validate.NoSeparator(),
-				},
-			},
-			"name": schema.StringAttribute{
-				Description: descriptions["name"],
-				Computed:    true,
-			},
-			"backup_schedule": schema.StringAttribute{
-				Computed: true,
-			},
-			"retention_days": schema.Int64Attribute{
-				Computed: true,
-			},
-			"flavor_id": schema.StringAttribute{
-				Computed: true,
-			},
-			"replicas": schema.Int64Attribute{
-				Computed: true,
-			},
-			"storage": schema.SingleNestedAttribute{
-				Computed: true,
-				Attributes: map[string]schema.Attribute{
-					"class": schema.StringAttribute{
-						Computed: true,
-					},
-					"size": schema.Int64Attribute{
-						Computed: true,
-					},
-				},
-			},
-			"version": schema.StringAttribute{
-				Computed: true,
-			},
-			"region": schema.StringAttribute{
-				// the region cannot be found, so it has to be passed
-				Optional:    true,
-				Description: descriptions["region"],
-			},
-			"encryption": schema.SingleNestedAttribute{
-				Computed: true,
-				Attributes: map[string]schema.Attribute{
-					"key_id": schema.StringAttribute{
-						Description: descriptions["key_id"],
-						Computed:    true,
-					},
-					"key_version": schema.StringAttribute{
-						Description: descriptions["key_version"],
-						Computed:    true,
-					},
-					"keyring_id": schema.StringAttribute{
-						Description: descriptions["keyring_id"],
-						Computed:    true,
-					},
-					"service_account": schema.StringAttribute{
-						Description: descriptions["service_account"],
-						Computed:    true,
-					},
-				},
-				Description: descriptions["encryption"],
-			},
-			"network": schema.SingleNestedAttribute{
-				Computed: true,
-				Attributes: map[string]schema.Attribute{
-					"access_scope": schema.StringAttribute{
-						Description: descriptions["access_scope"],
-						Computed:    true,
-					},
-					"acl": schema.ListAttribute{
-						Description: descriptions["acl"],
-						ElementType: types.StringType,
-						Computed:    true,
-					},
-					"instance_address": schema.StringAttribute{
-						Description: descriptions["instance_address"],
-						Computed:    true,
-					},
-					"router_address": schema.StringAttribute{
-						Description: descriptions["router_address"],
-						Computed:    true,
-					},
-				},
-				Description: descriptions["network"],
-			},
-		},
-	}
+func (r *instanceDataSource) Schema(ctx context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	resp.Schema = postgresflexalpha2.InstanceDataSourceSchema(ctx)
 }

 // Read refreshes the Terraform state with the latest data.
-func (r *instanceDataSource) Read(
-	ctx context.Context,
-	req datasource.ReadRequest,
-	resp *datasource.ReadResponse,
-) { // nolint:gocritic // function signature required by Terraform
-	var model Model
+func (r *instanceDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) { // nolint:gocritic // function signature required by Terraform
+	var model postgresflexalpha2.InstanceModel
 	diags := req.Config.Get(ctx, &model)
 	resp.Diagnostics.Append(diags...)
 	if resp.Diagnostics.HasError() {
@ -224,43 +93,12 @@ func (r *instanceDataSource) Read(

 	ctx = core.LogResponse(ctx)

-	var storage = &storageModel{}
-	if !model.Storage.IsNull() && !model.Storage.IsUnknown() {
-		diags = model.Storage.As(ctx, storage, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
-	var network = &networkModel{}
-	if !model.Network.IsNull() && !model.Network.IsUnknown() {
-		diags = model.Network.As(ctx, network, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
-	var encryption = &encryptionModel{}
-	if !model.Encryption.IsNull() && !model.Encryption.IsUnknown() {
-		diags = model.Encryption.As(ctx, encryption, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
-	err = mapFields(ctx, instanceResp, &model, storage, encryption, network, region)
+	err = mapGetDataInstanceResponseToModel(ctx, &model, instanceResp)
 	if err != nil {
-		core.LogAndAddError(
-			ctx,
-			&resp.Diagnostics,
-			"Error reading instance",
-			fmt.Sprintf("Processing API payload: %v", err),
-		)
+		core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading instance", fmt.Sprintf("Calling API: %v", err))
 		return
 	}
+
 	// Set refreshed state
 	diags = resp.State.Set(ctx, model)
 	resp.Diagnostics.Append(diags...)
--- a/stackit/internal/services/postgresflexalpha/instance/datasources_gen/instance_data_source_gen.go
+++ b/stackit/internal/services/postgresflexalpha/instance/datasources_gen/instance_data_source_gen.go
--- a/stackit/internal/services/postgresflexalpha/instance/datasources_gen/instances_data_source_gen.go
+++ b/stackit/internal/services/postgresflexalpha/instance/datasources_gen/instances_data_source_gen.go
--- a/stackit/internal/services/postgresflexalpha/instance/functions.go
+++ b/stackit/internal/services/postgresflexalpha/instance/functions.go
@ -3,217 +3,165 @@ package postgresflexalpha
 import (
 	"context"
 	"fmt"
-	"math"

 	"github.com/hashicorp/terraform-plugin-framework/attr"
 	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
+	"github.com/hashicorp/terraform-plugin-log/tflog"
 	postgresflex "github.com/mhenselin/terraform-provider-stackitprivatepreview/pkg/postgresflexalpha"
-	"github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/conversion"
-	"github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/core"
+	postgresflexalphadatasource "github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/instance/datasources_gen"
+	postgresflexalpharesource "github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/instance/resources_gen"
 	"github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/utils"
 )

-func mapFields(
-	ctx context.Context,
-	resp *postgresflex.GetInstanceResponse,
-	model *Model,
-	storage *storageModel,
-	encryption *encryptionModel,
-	network *networkModel,
-	region string,
-) error {
-	if resp == nil {
-		return fmt.Errorf("response input is nil")
-	}
-	if model == nil {
-		return fmt.Errorf("model input is nil")
-	}
-	instance := resp
+func mapGetInstanceResponseToModel(ctx context.Context, m *postgresflexalpharesource.InstanceModel, resp *postgresflex.GetInstanceResponse) error {
+	tflog.Info(ctx, ">>>> MSH DEBUG <<<<", map[string]interface{}{
+		"id":                         m.Id.ValueString(),
+		"instance_id":                m.InstanceId.ValueString(),
+		"backup_schedule":            m.BackupSchedule.ValueString(),
+		"flavor_id":                  m.FlavorId.ValueString(),
+		"encryption.kek_key_id":      m.Encryption.KekKeyId.ValueString(),
+		"encryption.kek_key_ring_id": m.Encryption.KekKeyRingId.ValueString(),
+		"encryption.kek_key_version": m.Encryption.KekKeyVersion.ValueString(),
+		"encryption.service_account": m.Encryption.ServiceAccount.ValueString(),
+		"is_deletable":               m.IsDeletable.ValueBool(),
+		"name":                       m.Name.ValueString(),
+		"status":                     m.Status.ValueString(),
+		"retention_days":             m.RetentionDays.ValueInt64(),
+		"replicas":                   m.Replicas.ValueInt64(),
+		"network.instance_address":   m.Network.InstanceAddress.ValueString(),
+		"network.router_address":     m.Network.RouterAddress.ValueString(),
+		"version":                    m.Version.ValueString(),
+		"network.acl":                m.Network.Acl.String(),
+	})

-	var instanceId string
-	if model.InstanceId.ValueString() != "" {
-		instanceId = model.InstanceId.ValueString()
-	} else if instance.Id != nil {
-		instanceId = *instance.Id
-	} else {
-		return fmt.Errorf("instance id not present")
+	m.BackupSchedule = types.StringValue(resp.GetBackupSchedule())
+	if resp.HasEncryption() {
+		m.Encryption = postgresflexalpharesource.NewEncryptionValueMust(
+			m.Encryption.AttributeTypes(ctx),
+			map[string]attr.Value{
+				"kek_key_id":      types.StringValue(resp.Encryption.GetKekKeyId()),
+				"kek_key_ring_id": types.StringValue(resp.Encryption.GetKekKeyRingId()),
+				"kek_key_version": types.StringValue(resp.Encryption.GetKekKeyVersion()),
+				"service_account": types.StringValue(resp.Encryption.GetServiceAccount()),
+			},
+		)
 	}
+	m.FlavorId = types.StringValue(resp.GetFlavorId())
+	if m.Id.IsNull() || m.Id.IsUnknown() {
+		m.Id = utils.BuildInternalTerraformId(m.ProjectId.ValueString(), m.Region.ValueString(), m.InstanceId.ValueString())
+	}
+	m.InstanceId = types.StringPointerValue(resp.Id)

-	var encryptionValues map[string]attr.Value
-	if instance.Encryption == nil {
-		encryptionValues = map[string]attr.Value{
-			"keyring_id":      encryption.KeyRingId,
-			"key_id":          encryption.KeyId,
-			"key_version":     encryption.KeyVersion,
-			"service_account": encryption.ServiceAccount,
-		}
-	} else {
-		encryptionValues = map[string]attr.Value{
-			"keyring_id":      types.StringValue(*instance.Encryption.KekKeyRingId),
-			"key_id":          types.StringValue(*instance.Encryption.KekKeyId),
-			"key_version":     types.StringValue(*instance.Encryption.KekKeyVersion),
-			"service_account": types.StringValue(*instance.Encryption.ServiceAccount),
-		}
-	}
-	encryptionObject, diags := types.ObjectValue(encryptionTypes, encryptionValues)
+	//m.IsDeletable = types.BoolUnknown()
+	//if isDel, ok := resp.GetIsDeletableOk(); ok {
+	//	m.IsDeletable = types.BoolValue(isDel)
+	m.IsDeletable = types.BoolValue(resp.GetIsDeletable())
+	//}
+
+	netAcl, diags := types.ListValueFrom(ctx, types.StringType, resp.Network.GetAcl())
 	if diags.HasError() {
-		return fmt.Errorf("creating encryption: %w", core.DiagsToError(diags))
+		return fmt.Errorf("failed converting network acl from response")
 	}

-	var networkValues map[string]attr.Value
-	if instance.Network == nil {
-		networkValues = map[string]attr.Value{
-			"acl":              network.ACL,
-			"access_scope":     network.AccessScope,
-			"instance_address": network.InstanceAddress,
-			"router_address":   network.RouterAddress,
-		}
-	} else {
-		aclList, diags := types.ListValueFrom(ctx, types.StringType, *instance.Network.Acl)
-		if diags.HasError() {
-			return fmt.Errorf("creating network (acl list): %w", core.DiagsToError(diags))
-		}
-
-		networkValues = map[string]attr.Value{
-			"acl":              aclList,
-			"access_scope":     types.StringPointerValue((*string)(instance.Network.AccessScope)),
-			"instance_address": types.StringPointerValue(instance.Network.InstanceAddress),
-			"router_address":   types.StringPointerValue(instance.Network.RouterAddress),
-		}
+	netInstAdd := types.StringValue("")
+	if instAdd, ok := resp.Network.GetInstanceAddressOk(); ok {
+		netInstAdd = types.StringValue(instAdd)
 	}
-	networkObject, diags := types.ObjectValue(networkTypes, networkValues)
+
+	netRtrAdd := types.StringValue("")
+	if rtrAdd, ok := resp.Network.GetRouterAddressOk(); ok {
+		netRtrAdd = types.StringValue(rtrAdd)
+	}
+
+	net, diags := postgresflexalpharesource.NewNetworkValue(
+		postgresflexalpharesource.NetworkValue{}.AttributeTypes(ctx),
+		map[string]attr.Value{
+			"access_scope":     basetypes.NewStringValue(string(resp.Network.GetAccessScope())),
+			"acl":              netAcl,
+			"instance_address": netInstAdd,
+			"router_address":   netRtrAdd,
+		},
+	)
 	if diags.HasError() {
-		return fmt.Errorf("creating network: %w", core.DiagsToError(diags))
+		return fmt.Errorf("failed converting network from response")
 	}

-	var storageValues map[string]attr.Value
-	if instance.Storage == nil {
-		storageValues = map[string]attr.Value{
-			"class": storage.Class,
-			"size":  storage.Size,
-		}
-	} else {
-		storageValues = map[string]attr.Value{
-			"class": types.StringValue(*instance.Storage.PerformanceClass),
-			"size":  types.Int64PointerValue(instance.Storage.Size),
-		}
-	}
-	storageObject, diags := types.ObjectValue(storageTypes, storageValues)
+	m.Network = net
+	m.Replicas = types.Int64Value(int64(resp.GetReplicas()))
+	m.RetentionDays = types.Int64Value(resp.GetRetentionDays())
+
+	m.Name = types.StringValue(resp.GetName())
+
+	//m.Status = types.StringUnknown()
+	//if status, ok := resp.GetStatusOk(); ok {
+	//	m.Status = types.StringValue(string(status))
+	//}
+	m.Status = types.StringValue(string(resp.GetStatus()))
+
+	storage, diags := postgresflexalpharesource.NewStorageValue(
+		postgresflexalpharesource.StorageValue{}.AttributeTypes(ctx),
+		map[string]attr.Value{
+			"performance_class": types.StringValue(resp.Storage.GetPerformanceClass()),
+			"size":              types.Int64Value(resp.Storage.GetSize()),
+		},
+	)
 	if diags.HasError() {
-		return fmt.Errorf("creating storage: %w", core.DiagsToError(diags))
+		return fmt.Errorf("failed converting storage from response")
 	}
+	m.Storage = storage

-	if instance.Replicas == nil {
-		diags.AddError("error mapping fields", "replicas is nil")
-		return fmt.Errorf("replicas is nil")
-	}
-
-	model.Id = utils.BuildInternalTerraformId(model.ProjectId.ValueString(), region, instanceId)
-	model.InstanceId = types.StringValue(instanceId)
-	model.Name = types.StringPointerValue(instance.Name)
-	model.BackupSchedule = types.StringPointerValue(instance.BackupSchedule)
-	model.FlavorId = types.StringPointerValue(instance.FlavorId)
-	model.Replicas = types.Int64Value(int64(*instance.Replicas))
-	model.Storage = storageObject
-	model.Version = types.StringPointerValue(instance.Version)
-	model.Region = types.StringValue(region)
-	model.Encryption = encryptionObject
-	model.Network = networkObject
+	m.Version = types.StringValue(resp.GetVersion())
 	return nil
 }

-func toCreatePayload(
-	model *Model,
-	storage *storageModel,
-	enc *encryptionModel,
-	net *networkModel,
-) (*postgresflex.CreateInstanceRequestPayload, error) {
-	if model == nil {
-		return nil, fmt.Errorf("nil model")
-	}
-	if storage == nil {
-		return nil, fmt.Errorf("nil storage")
+func mapGetDataInstanceResponseToModel(ctx context.Context, m *postgresflexalphadatasource.InstanceModel, resp *postgresflex.GetInstanceResponse) error {
+	m.BackupSchedule = types.StringValue(resp.GetBackupSchedule())
+	//nolint:gocritic
+	// m.Encryption = postgresflexalpharesource.EncryptionValue{
+	//	KekKeyId:       types.StringValue(resp.Encryption.GetKekKeyId()),
+	//	KekKeyRingId:   types.StringValue(resp.Encryption.GetKekKeyRingId()),
+	//	KekKeyVersion:  types.StringValue(resp.Encryption.GetKekKeyVersion()),
+	//	ServiceAccount: types.StringValue(resp.Encryption.GetServiceAccount()),
+	// }
+	m.FlavorId = types.StringValue(resp.GetFlavorId())
+	m.Id = utils.BuildInternalTerraformId(m.ProjectId.ValueString(), m.Region.ValueString(), m.InstanceId.ValueString())
+	m.InstanceId = types.StringPointerValue(resp.Id)
+	m.IsDeletable = types.BoolValue(resp.GetIsDeletable())
+	m.Name = types.StringValue(resp.GetName())
+	netAcl, diags := types.ListValueFrom(ctx, types.StringType, resp.Network.GetAcl())
+	if diags.HasError() {
+		return fmt.Errorf("failed converting network acl from response")
 	}

-	var replVal int32
-	if !model.Replicas.IsNull() && !model.Replicas.IsUnknown() {
-		if model.Replicas.ValueInt64() > math.MaxInt32 {
-			return nil, fmt.Errorf("replica count too big: %d", model.Replicas.ValueInt64())
-		}
-		replVal = int32(model.Replicas.ValueInt64()) // nolint:gosec // check is performed above
-	}
-
-	storagePayload := &postgresflex.CreateInstanceRequestPayloadGetStorageArgType{
-		PerformanceClass: conversion.StringValueToPointer(storage.Class),
-		Size:             conversion.Int64ValueToPointer(storage.Size),
-	}
-
-	encryptionPayload := &postgresflex.CreateInstanceRequestPayloadGetEncryptionArgType{}
-	if enc != nil {
-		encryptionPayload.KekKeyId = conversion.StringValueToPointer(enc.KeyId)
-		encryptionPayload.KekKeyVersion = conversion.StringValueToPointer(enc.KeyVersion)
-		encryptionPayload.KekKeyRingId = conversion.StringValueToPointer(enc.KeyRingId)
-		encryptionPayload.ServiceAccount = conversion.StringValueToPointer(enc.ServiceAccount)
-	}
-
-	var aclElements []string
-	if net != nil && !net.ACL.IsNull() && !net.ACL.IsUnknown() {
-		aclElements = make([]string, 0, len(net.ACL.Elements()))
-		diags := net.ACL.ElementsAs(context.TODO(), &aclElements, false)
-		if diags.HasError() {
-			return nil, fmt.Errorf("creating network: %w", core.DiagsToError(diags))
-		}
-	}
-
-	if len(aclElements) < 1 {
-		return nil, fmt.Errorf("no acl elements found")
-	}
-
-	networkPayload := &postgresflex.CreateInstanceRequestPayloadGetNetworkArgType{}
-	if net != nil {
-		networkPayload = &postgresflex.CreateInstanceRequestPayloadGetNetworkArgType{
-			AccessScope: postgresflex.InstanceNetworkGetAccessScopeAttributeType(conversion.StringValueToPointer(net.AccessScope)),
-			Acl:         &aclElements,
-		}
-	}
-
-	return &postgresflex.CreateInstanceRequestPayload{
-		Acl:            &aclElements,
-		BackupSchedule: conversion.StringValueToPointer(model.BackupSchedule),
-		Encryption:     encryptionPayload,
-		FlavorId:       conversion.StringValueToPointer(model.FlavorId),
-		Name:           conversion.StringValueToPointer(model.Name),
-		Network:        networkPayload,
-		Replicas:       postgresflex.CreateInstanceRequestPayloadGetReplicasAttributeType(&replVal),
-		RetentionDays:  conversion.Int64ValueToPointer(model.RetentionDays),
-		Storage:        storagePayload,
-		Version:        conversion.StringValueToPointer(model.Version),
-	}, nil
-}
-
-func toUpdatePayload(
-	model *Model,
-	storage *storageModel,
-	_ *networkModel,
-) (*postgresflex.UpdateInstancePartiallyRequestPayload, error) {
-	if model == nil {
-		return nil, fmt.Errorf("nil model")
-	}
-	if storage == nil {
-		return nil, fmt.Errorf("nil storage")
-	}
-
-	return &postgresflex.UpdateInstancePartiallyRequestPayload{
-		// Acl: postgresflexalpha.UpdateInstancePartiallyRequestPayloadGetAclAttributeType{
-		//	Items: &acl,
-		// },
-		BackupSchedule: conversion.StringValueToPointer(model.BackupSchedule),
-		FlavorId:       conversion.StringValueToPointer(model.FlavorId),
-		Name:           conversion.StringValueToPointer(model.Name),
-		// Replicas:       conversion.Int64ValueToPointer(model.Replicas),
-		Storage: &postgresflex.StorageUpdate{
-			Size: conversion.Int64ValueToPointer(storage.Size),
+	net, diags := postgresflexalphadatasource.NewNetworkValue(
+		postgresflexalphadatasource.NetworkValue{}.AttributeTypes(ctx),
+		map[string]attr.Value{
+			"access_scope":     types.StringValue(string(resp.Network.GetAccessScope())),
+			"acl":              netAcl,
+			"instance_address": types.StringValue(resp.Network.GetInstanceAddress()),
+			"router_address":   types.StringValue(resp.Network.GetRouterAddress()),
 		},
-		Version: conversion.StringValueToPointer(model.Version),
-	}, nil
+	)
+	if diags.HasError() {
+		return fmt.Errorf("failed converting network from response")
+	}
+
+	m.Network = net
+	m.Replicas = types.Int64Value(int64(resp.GetReplicas()))
+	m.RetentionDays = types.Int64Value(resp.GetRetentionDays())
+	m.Status = types.StringValue(string(resp.GetStatus()))
+	storage, diags := postgresflexalphadatasource.NewStorageValue(
+		postgresflexalphadatasource.StorageValue{}.AttributeTypes(ctx),
+		map[string]attr.Value{
+			"performance_class": types.StringValue(resp.Storage.GetPerformanceClass()),
+			"size":              types.Int64Value(resp.Storage.GetSize()),
+		},
+	)
+	if diags.HasError() {
+		return fmt.Errorf("failed converting storage from response")
+	}
+	m.Storage = storage
+	m.Version = types.StringValue(resp.GetVersion())
+	return nil
 }
--- a/stackit/internal/services/postgresflexalpha/instance/models.go
+++ b/stackit/internal/services/postgresflexalpha/instance/models.go
@ -1,63 +0,0 @@
-package postgresflexalpha
-
-import (
-	"github.com/hashicorp/terraform-plugin-framework/attr"
-	"github.com/hashicorp/terraform-plugin-framework/types"
-	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
-)
-
-type Model struct {
-	Id             types.String `tfsdk:"id"` // needed by TF
-	InstanceId     types.String `tfsdk:"instance_id"`
-	ProjectId      types.String `tfsdk:"project_id"`
-	Name           types.String `tfsdk:"name"`
-	BackupSchedule types.String `tfsdk:"backup_schedule"`
-	FlavorId       types.String `tfsdk:"flavor_id"`
-	Replicas       types.Int64  `tfsdk:"replicas"`
-	RetentionDays  types.Int64  `tfsdk:"retention_days"`
-	Storage        types.Object `tfsdk:"storage"`
-	Version        types.String `tfsdk:"version"`
-	Region         types.String `tfsdk:"region"`
-	Encryption     types.Object `tfsdk:"encryption"`
-	Network        types.Object `tfsdk:"network"`
-}
-
-type encryptionModel struct {
-	KeyRingId      types.String `tfsdk:"keyring_id"`
-	KeyId          types.String `tfsdk:"key_id"`
-	KeyVersion     types.String `tfsdk:"key_version"`
-	ServiceAccount types.String `tfsdk:"service_account"`
-}
-
-var encryptionTypes = map[string]attr.Type{
-	"keyring_id":      basetypes.StringType{},
-	"key_id":          basetypes.StringType{},
-	"key_version":     basetypes.StringType{},
-	"service_account": basetypes.StringType{},
-}
-
-type networkModel struct {
-	ACL             types.List   `tfsdk:"acl"`
-	AccessScope     types.String `tfsdk:"access_scope"`
-	InstanceAddress types.String `tfsdk:"instance_address"`
-	RouterAddress   types.String `tfsdk:"router_address"`
-}
-
-var networkTypes = map[string]attr.Type{
-	"acl":              basetypes.ListType{ElemType: types.StringType},
-	"access_scope":     basetypes.StringType{},
-	"instance_address": basetypes.StringType{},
-	"router_address":   basetypes.StringType{},
-}
-
-// Struct corresponding to Model.Storage
-type storageModel struct {
-	Class types.String `tfsdk:"class"`
-	Size  types.Int64  `tfsdk:"size"`
-}
-
-// Types corresponding to storageModel
-var storageTypes = map[string]attr.Type{
-	"class": basetypes.StringType{},
-	"size":  basetypes.Int64Type{},
-}
--- a/stackit/internal/services/postgresflexalpha/instance/planModifiers.yaml
+++ b/stackit/internal/services/postgresflexalpha/instance/planModifiers.yaml
@ -0,0 +1,112 @@
+fields:
+  - name: 'backup_schedule'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'encryption.kek_key_id'
+    validators:
+      - validate.NoSeparator
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'encryption.kek_key_ring_id'
+    validators:
+      - validate.NoSeparator
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'encryption.kek_key_version'
+    validators:
+      - validate.NoSeparator
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'encryption.service_account'
+    validators:
+      - validate.NoSeparator
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'flavor_id'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'id'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'instance_id'
+    validators:
+      - validate.NoSeparator
+      - validate.UUID
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'is_deletable'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'name'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'network.access_scope'
+    validators:
+      - validate.NoSeparator
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'network.acl'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'network.instance_address'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'network.router_address'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'project_id'
+    validators:
+      - validate.NoSeparator
+      - validate.UUID
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'region'
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'replicas'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'retention_days'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'status'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'storage'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'storage.performance_class'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'storage.size'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'version'
+    modifiers:
+      - 'UseStateForUnknown'
--- a/stackit/internal/services/postgresflexalpha/instance/resource.go
+++ b/stackit/internal/services/postgresflexalpha/instance/resource.go
@ -2,36 +2,29 @@ package postgresflexalpha

 import (
 	"context"
+	_ "embed"
 	"fmt"
+	"math"
 	"net/http"
-	"regexp"
 	"strings"

-	"github.com/hashicorp/terraform-plugin-framework/resource/schema/int64planmodifier"
-	postgresflex "github.com/mhenselin/terraform-provider-stackitprivatepreview/pkg/postgresflexalpha"
-	"github.com/mhenselin/terraform-provider-stackitprivatepreview/pkg/postgresflexalpha/wait"
-	postgresflexUtils "github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/utils"
-
-	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
-	"github.com/hashicorp/terraform-plugin-framework/resource/schema/listplanmodifier"
-	"github.com/hashicorp/terraform-plugin-framework/resource/schema/stringdefault"
-	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
-	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
-	"github.com/hashicorp/terraform-plugin-log/tflog"
-	"github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/conversion"
-	"github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/core"
-	"github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/utils"
-	"github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/validate"
-
 	"github.com/hashicorp/terraform-plugin-framework/path"
 	"github.com/hashicorp/terraform-plugin-framework/resource"
-	"github.com/hashicorp/terraform-plugin-framework/resource/schema"
-	"github.com/hashicorp/terraform-plugin-framework/resource/schema/planmodifier"
-	"github.com/hashicorp/terraform-plugin-framework/resource/schema/stringplanmodifier"
+	"github.com/hashicorp/terraform-plugin-framework/resource/identityschema"
 	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/hashicorp/terraform-plugin-log/tflog"
+	postgresflex "github.com/mhenselin/terraform-provider-stackitprivatepreview/pkg/postgresflexalpha"
+	"github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/conversion"
+	"github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/core"
+	postgresflexalpha "github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/instance/resources_gen"
+	postgresflexUtils "github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/utils"
+	"github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/utils"
+	wait "github.com/mhenselin/terraform-provider-stackitprivatepreview/stackit/internal/wait/postgresflexalpha"
 	"github.com/stackitcloud/stackit-sdk-go/core/oapierror"
 )

+const packageName = "postgresflexalpha"
+
 // Ensure the implementation satisfies the expected interfaces.
 var (
 	_ resource.Resource                   = &instanceResource{}
@ -39,7 +32,7 @@ var (
 	_ resource.ResourceWithImportState    = &instanceResource{}
 	_ resource.ResourceWithModifyPlan     = &instanceResource{}
 	_ resource.ResourceWithValidateConfig = &instanceResource{}
-	// _ resource.ResourceWithIdentity       = &instanceResource{}
+	_ resource.ResourceWithIdentity       = &instanceResource{}
 )

 // NewInstanceResource is a helper function to simplify the provider implementation.
@ -53,12 +46,14 @@ type instanceResource struct {
 	providerData core.ProviderData
 }

-func (r *instanceResource) ValidateConfig(
-	ctx context.Context,
-	req resource.ValidateConfigRequest,
-	resp *resource.ValidateConfigResponse,
-) {
-	var data Model
+type InstanceResourceIdentityModel struct {
+	ProjectID  types.String `tfsdk:"project_id"`
+	Region     types.String `tfsdk:"region"`
+	InstanceID types.String `tfsdk:"instance_id"`
+}
+
+func (r *instanceResource) ValidateConfig(ctx context.Context, req resource.ValidateConfigRequest, resp *resource.ValidateConfigResponse) {
+	var data postgresflexalpha.InstanceModel
 	resp.Diagnostics.Append(req.Config.Get(ctx, &data)...)

 	if resp.Diagnostics.HasError() {
@ -77,12 +72,8 @@ func (r *instanceResource) ValidateConfig(

 // ModifyPlan implements resource.ResourceWithModifyPlan.
 // Use the modifier to set the effective region in the current plan.
-func (r *instanceResource) ModifyPlan(
-	ctx context.Context,
-	req resource.ModifyPlanRequest,
-	resp *resource.ModifyPlanResponse,
-) { // nolint:gocritic // function signature required by Terraform
-	var configModel Model
+func (r *instanceResource) ModifyPlan(ctx context.Context, req resource.ModifyPlanRequest, resp *resource.ModifyPlanResponse) { // nolint:gocritic // function signature required by Terraform
+	var configModel postgresflexalpha.InstanceModel
 	// skip initial empty configuration to avoid follow-up errors
 	if req.Config.Raw.IsNull() {
 		return
@ -92,7 +83,7 @@ func (r *instanceResource) ModifyPlan(
 		return
 	}

-	var planModel Model
+	var planModel postgresflexalpha.InstanceModel
 	resp.Diagnostics.Append(req.Plan.Get(ctx, &planModel)...)
 	if resp.Diagnostics.HasError() {
 		return
@ -134,252 +125,54 @@ func (r *instanceResource) Configure(
 	tflog.Info(ctx, "Postgres Flex instance client configured")
 }

+/*
+  until tfplugingen framework can handle plan modifiers, we use a function to add them
+*/
+
+//go:embed planModifiers.yaml
+var modifiersFileByte []byte
+
 // Schema defines the schema for the resource.
-func (r *instanceResource) Schema(_ context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
-	descriptions := map[string]string{
-		"main":             "Postgres Flex instance resource schema. Must have a `region` specified in the provider configuration.",
-		"id":               "Terraform's internal resource ID. It is structured as \"`project_id`,`region`,`instance_id`\".",
-		"instance_id":      "ID of the PostgresFlex instance.",
-		"project_id":       "STACKIT project ID to which the instance is associated.",
-		"name":             "Instance name.",
-		"backup_schedule":  "The schedule for on what time and how often the database backup will be created. The schedule is written as a cron schedule.",
-		"retention_days":   "The days of the retention period.",
-		"flavor_id":        "The ID of the flavor.",
-		"replicas":         "The number of replicas.",
-		"storage":          "The block of the storage configuration.",
-		"storage_class":    "The storage class used.",
-		"storage_size":     "The disk size of the storage.",
-		"region":           "The resource region. If not defined, the provider region is used.",
-		"version":          "The database version used.",
-		"encryption":       "The encryption block.",
-		"keyring_id":       "KeyRing ID of the encryption key.",
-		"key_id":           "Key ID of the encryption key.",
-		"key_version":      "Key version of the encryption key.",
-		"service_account":  "The service account ID of the service account.",
-		"network":          "The network block configuration.",
-		"access_scope":     "The access scope. (Either SNA or PUBLIC)",
-		"acl":              "The Access Control List (ACL) for the PostgresFlex instance.",
-		"instance_address": "The returned instance address.",
-		"router_address":   "The returned router address.",
+func (r *instanceResource) Schema(ctx context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
+	schema := postgresflexalpha.InstanceResourceSchema(ctx)
+	fields, err := postgresflexUtils.ReadModifiersConfig(modifiersFileByte)
+	if err != nil {
+		resp.Diagnostics.AddError("error during read modifiers config file", err.Error())
+		return
 	}

-	resp.Schema = schema.Schema{
-		Description: descriptions["main"],
-		Attributes: map[string]schema.Attribute{
-			"id": schema.StringAttribute{
-				Description: descriptions["id"],
-				Computed:    true,
-				PlanModifiers: []planmodifier.String{
-					stringplanmodifier.UseStateForUnknown(),
-				},
+	err = postgresflexUtils.AddPlanModifiersToResourceSchema(fields, &schema)
+	if err != nil {
+		resp.Diagnostics.AddError("error adding plan modifiers", err.Error())
+		return
+	}
+	resp.Schema = schema
+}
+
+func (r *instanceResource) IdentitySchema(_ context.Context, _ resource.IdentitySchemaRequest, resp *resource.IdentitySchemaResponse) {
+	resp.IdentitySchema = identityschema.Schema{
+		Attributes: map[string]identityschema.Attribute{
+			"project_id": identityschema.StringAttribute{
+				RequiredForImport: true, // must be set during import by the practitioner
 			},
-			"instance_id": schema.StringAttribute{
-				Description: descriptions["instance_id"],
-				Computed:    true,
-				PlanModifiers: []planmodifier.String{
-					stringplanmodifier.UseStateForUnknown(),
-				},
-				Validators: []validator.String{
-					validate.UUID(),
-					validate.NoSeparator(),
-				},
+			"region": identityschema.StringAttribute{
+				RequiredForImport: true, // can be defaulted by the provider configuration
 			},
-			"project_id": schema.StringAttribute{
-				Description: descriptions["project_id"],
-				Required:    true,
-				PlanModifiers: []planmodifier.String{
-					stringplanmodifier.RequiresReplace(),
-					stringplanmodifier.UseStateForUnknown(),
-				},
-				Validators: []validator.String{
-					validate.UUID(),
-					validate.NoSeparator(),
-				},
-			},
-			"name": schema.StringAttribute{
-				Description: descriptions["name"],
-				Required:    true,
-				Validators: []validator.String{
-					stringvalidator.LengthAtLeast(1),
-					stringvalidator.RegexMatches(
-						regexp.MustCompile("^[a-z]([-a-z0-9]*[a-z0-9])?$"),
-						"must start with a letter, must have lower case letters, numbers or hyphens, and no hyphen at the end",
-					),
-				},
-			},
-			"backup_schedule": schema.StringAttribute{
-				Required: true,
-			},
-			"retention_days": schema.Int64Attribute{
-				Description: descriptions["retention_days"],
-				Required:    true,
-			},
-			"flavor_id": schema.StringAttribute{
-				Required: true,
-			},
-			"replicas": schema.Int64Attribute{
-				Required: true,
-				PlanModifiers: []planmodifier.Int64{
-					int64planmodifier.RequiresReplace(),
-				},
-			},
-			"storage": schema.SingleNestedAttribute{
-				Required: true,
-				Attributes: map[string]schema.Attribute{
-					"class": schema.StringAttribute{
-						Required:    true,
-						Description: descriptions["storage_class"],
-						PlanModifiers: []planmodifier.String{
-							stringplanmodifier.RequiresReplace(),
-						},
-					},
-					"size": schema.Int64Attribute{
-						Description: descriptions["storage_size"],
-						Required:    true,
-						// PlanModifiers: []planmodifier.Int64{
-						// TODO - req replace if new size smaller than state size
-						// int64planmodifier.RequiresReplaceIf(),
-						// },
-					},
-				},
-			},
-			"version": schema.StringAttribute{
-				Description: descriptions["version"],
-				Required:    true,
-			},
-			"region": schema.StringAttribute{
-				Optional: true,
-				// must be computed to allow for storing the override value from the provider
-				Computed:    true,
-				Description: descriptions["region"],
-				PlanModifiers: []planmodifier.String{
-					stringplanmodifier.RequiresReplace(),
-				},
-			},
-			"encryption": schema.SingleNestedAttribute{
-				Required: true,
-				Attributes: map[string]schema.Attribute{
-					"key_id": schema.StringAttribute{
-						Description: descriptions["key_id"],
-						Required:    true,
-						PlanModifiers: []planmodifier.String{
-							stringplanmodifier.RequiresReplace(),
-						},
-						Validators: []validator.String{
-							validate.NoSeparator(),
-						},
-					},
-					"key_version": schema.StringAttribute{
-						Description: descriptions["key_version"],
-						Required:    true,
-						PlanModifiers: []planmodifier.String{
-							stringplanmodifier.RequiresReplace(),
-						},
-						Validators: []validator.String{
-							validate.NoSeparator(),
-						},
-					},
-					"keyring_id": schema.StringAttribute{
-						Description: descriptions["keyring_id"],
-						Required:    true,
-						PlanModifiers: []planmodifier.String{
-							stringplanmodifier.RequiresReplace(),
-						},
-						Validators: []validator.String{
-							validate.NoSeparator(),
-						},
-					},
-					"service_account": schema.StringAttribute{
-						Description: descriptions["service_account"],
-						Required:    true,
-						PlanModifiers: []planmodifier.String{
-							stringplanmodifier.RequiresReplace(),
-						},
-						Validators: []validator.String{
-							validate.NoSeparator(),
-						},
-					},
-				},
-				Description: descriptions["encryption"],
-				//Validators:          nil,
-				PlanModifiers: []planmodifier.Object{},
-			},
-			"network": schema.SingleNestedAttribute{
-				Required: true,
-				Attributes: map[string]schema.Attribute{
-					"access_scope": schema.StringAttribute{
-						Default: stringdefault.StaticString(
-							"PUBLIC",
-						),
-						Description: descriptions["access_scope"],
-						Computed:    true,
-						Optional:    true,
-						PlanModifiers: []planmodifier.String{
-							stringplanmodifier.RequiresReplace(),
-							stringplanmodifier.UseStateForUnknown(),
-						},
-						Validators: []validator.String{
-							validate.NoSeparator(),
-							stringvalidator.OneOf("SNA", "PUBLIC"),
-						},
-					},
-					"acl": schema.ListAttribute{
-						Description: descriptions["acl"],
-						ElementType: types.StringType,
-						Required:    true,
-						PlanModifiers: []planmodifier.List{
-							listplanmodifier.UseStateForUnknown(),
-						},
-					},
-					"instance_address": schema.StringAttribute{
-						Description: descriptions["instance_address"],
-						Computed:    true,
-						Optional:    true,
-						PlanModifiers: []planmodifier.String{
-							stringplanmodifier.UseStateForUnknown(),
-						},
-					},
-					"router_address": schema.StringAttribute{
-						Description: descriptions["router_address"],
-						Computed:    true,
-						Optional:    true,
-						PlanModifiers: []planmodifier.String{
-							stringplanmodifier.UseStateForUnknown(),
-						},
-					},
-				},
-				Description: descriptions["network"],
-				//MarkdownDescription: "",
-				//Validators:          nil,
-				PlanModifiers: []planmodifier.Object{},
+			"instance_id": identityschema.StringAttribute{
+				RequiredForImport: true, // can be defaulted by the provider configuration
 			},
 		},
 	}
 }

-// func (r *instanceResource) IdentitySchema(_ context.Context, _ resource.IdentitySchemaRequest, resp *resource.IdentitySchemaResponse) {
-//	resp.IdentitySchema = identityschema.Schema{
-//		Attributes: map[string]identityschema.Attribute{
-//			"project_id": identityschema.StringAttribute{
-//				RequiredForImport: true, // must be set during import by the practitioner
-//			},
-//			"region": identityschema.StringAttribute{
-//				RequiredForImport: true, // must be set during import by the practitioner
-//			},
-//			"instance_id": identityschema.StringAttribute{
-//				RequiredForImport: true, // must be set during import by the practitioner
-//			},
-//		},
-//	}
-//}
-
 // Create creates the resource and sets the initial Terraform state.
 func (r *instanceResource) Create(
 	ctx context.Context,
 	req resource.CreateRequest,
 	resp *resource.CreateResponse,
 ) { // nolint:gocritic // function signature required by Terraform
-	var model Model
+	var model postgresflexalpha.InstanceModel
+
 	diags := req.Plan.Get(ctx, &model)
 	resp.Diagnostics.Append(diags...)
 	if resp.Diagnostics.HasError() {
@ -393,96 +186,57 @@ func (r *instanceResource) Create(
 	ctx = tflog.SetField(ctx, "project_id", projectId)
 	ctx = tflog.SetField(ctx, "region", region)

-	var storage = &storageModel{}
-	if !model.Storage.IsNull() && !model.Storage.IsUnknown() {
-		diags = model.Storage.As(ctx, storage, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
-	var encryption = &encryptionModel{}
-	if !model.Encryption.IsNull() && !model.Encryption.IsUnknown() {
-		diags = model.Encryption.As(ctx, encryption, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
-	var network = &networkModel{}
-	if !model.Network.IsNull() && !model.Network.IsUnknown() {
-		diags = model.Network.As(ctx, network, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
-	var acl []string
-	if !network.ACL.IsNull() && !network.ACL.IsUnknown() {
-		diags = network.ACL.ElementsAs(ctx, &acl, false)
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
-	// Generate API request body from model
-	payload, err := toCreatePayload(&model, storage, encryption, network)
-	if err != nil {
-		core.LogAndAddError(
-			ctx,
-			&resp.Diagnostics,
-			"Error creating instance",
-			fmt.Sprintf("Creating API payload: %v", err),
-		)
+	var netAcl []string
+	diag := model.Network.Acl.ElementsAs(ctx, &netAcl, false)
+	resp.Diagnostics.Append(diags...)
+	if diag.HasError() {
 		return
 	}
+
+	if model.Replicas.ValueInt64() > math.MaxInt32 {
+		resp.Diagnostics.AddError("invalid int32 value", "provided int64 value does not fit into int32")
+		return
+	}
+	replVal := int32(model.Replicas.ValueInt64()) // nolint:gosec // check is performed above
+	payload := modelToCreateInstancePayload(netAcl, model, replVal)
+
 	// Create new instance
-	createResp, err := r.client.CreateInstanceRequest(
-		ctx,
-		projectId,
-		region,
-	).CreateInstanceRequestPayload(*payload).Execute()
+	createResp, err := r.client.CreateInstanceRequest(ctx, projectId, region).CreateInstanceRequestPayload(payload).Execute()
 	if err != nil {
-		core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating instance", fmt.Sprintf("Calling API: %v", err))
+		core.LogAndAddError(ctx, &resp.Diagnostics, "error creating instance", fmt.Sprintf("Calling API: %v", err))
 		return
 	}

 	ctx = core.LogResponse(ctx)
-	instanceId := *createResp.Id
+	instanceId, ok := createResp.GetIdOk()
+	if !ok {
+		core.LogAndAddError(ctx, &resp.Diagnostics, "error creating instance", "could not find instance id in response")
+		return
+	}

-	model.InstanceId = types.StringValue(instanceId)
-	model.Id = utils.BuildInternalTerraformId(projectId, region, instanceId)
-	resp.Diagnostics.Append(resp.State.Set(ctx, &model)...)
+	// Set data returned by API in identity
+	identity := InstanceResourceIdentityModel{
+		ProjectID:  types.StringValue(projectId),
+		Region:     types.StringValue(region),
+		InstanceID: types.StringValue(instanceId),
+	}
+	resp.Diagnostics.Append(resp.Identity.Set(ctx, identity)...)
 	if resp.Diagnostics.HasError() {
 		return
 	}

 	waitResp, err := wait.CreateInstanceWaitHandler(ctx, r.client, projectId, region, instanceId).WaitWithContext(ctx)
 	if err != nil {
-		core.LogAndAddError(
-			ctx,
-			&resp.Diagnostics,
-			"Error creating instance",
-			fmt.Sprintf("Wait handler error: %v", err),
-		)
+		core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating instance", fmt.Sprintf("Wait handler error: %v", err))
 		return
 	}

-	// Map response body to schema
-	err = mapFields(ctx, waitResp, &model, storage, encryption, network, region)
+	err = mapGetInstanceResponseToModel(ctx, &model, waitResp)
 	if err != nil {
-		core.LogAndAddError(
-			ctx,
-			&resp.Diagnostics,
-			"Error creating instance",
-			fmt.Sprintf("Processing API payload: %v", err),
-		)
+		core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating instance", fmt.Sprintf("Error creating model: %v", err))
 		return
 	}
+
 	// Set state to fully populated data
 	diags = resp.State.Set(ctx, model)
 	resp.Diagnostics.Append(diags...)
@ -492,55 +246,97 @@ func (r *instanceResource) Create(
 	tflog.Info(ctx, "Postgres Flex instance created")
 }

+func modelToCreateInstancePayload(netAcl []string, model postgresflexalpha.InstanceModel, replVal int32) postgresflex.CreateInstanceRequestPayload {
+	payload := postgresflex.CreateInstanceRequestPayload{
+		BackupSchedule: model.BackupSchedule.ValueStringPointer(),
+		Encryption: &postgresflex.InstanceEncryption{
+			KekKeyId:       model.Encryption.KekKeyId.ValueStringPointer(),
+			KekKeyRingId:   model.Encryption.KekKeyRingId.ValueStringPointer(),
+			KekKeyVersion:  model.Encryption.KekKeyVersion.ValueStringPointer(),
+			ServiceAccount: model.Encryption.ServiceAccount.ValueStringPointer(),
+		},
+		FlavorId: model.FlavorId.ValueStringPointer(),
+		Name:     model.Name.ValueStringPointer(),
+		Network: &postgresflex.InstanceNetwork{
+			AccessScope: postgresflex.InstanceNetworkGetAccessScopeAttributeType(
+				model.Network.AccessScope.ValueStringPointer(),
+			),
+			Acl:             &netAcl,
+			InstanceAddress: model.Network.InstanceAddress.ValueStringPointer(),
+			RouterAddress:   model.Network.RouterAddress.ValueStringPointer(),
+		},
+		Replicas:      postgresflex.CreateInstanceRequestPayloadGetReplicasAttributeType(&replVal),
+		RetentionDays: model.RetentionDays.ValueInt64Pointer(),
+		Storage: &postgresflex.StorageCreate{
+			PerformanceClass: model.Storage.PerformanceClass.ValueStringPointer(),
+			Size:             model.Storage.Size.ValueInt64Pointer(),
+		},
+		Version: model.Version.ValueStringPointer(),
+	}
+	return payload
+}
+
 // Read refreshes the Terraform state with the latest data.
-func (r *instanceResource) Read(
-	ctx context.Context,
-	req resource.ReadRequest,
-	resp *resource.ReadResponse,
-) { // nolint:gocritic // function signature required by Terraform
-	var model Model
+func (r *instanceResource) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) { // nolint:gocritic // function signature required by Terraform
+	functionErrorSummary := "read instance failed"
+
+	var model postgresflexalpha.InstanceModel
 	diags := req.State.Get(ctx, &model)
 	resp.Diagnostics.Append(diags...)
 	if resp.Diagnostics.HasError() {
 		return
 	}

+	// Read identity data
+	var identityData InstanceResourceIdentityModel
+	resp.Diagnostics.Append(req.Identity.Get(ctx, &identityData)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
 	ctx = core.InitProviderContext(ctx)

-	projectId := model.ProjectId.ValueString()
-	instanceId := model.InstanceId.ValueString()
-	region := r.providerData.GetRegionWithOverride(model.Region)
+	// projectId := model.ProjectId.ValueString()
+	// region := r.providerData.GetRegionWithOverride(model.Region)
+	// instanceId := model.InstanceId.ValueString()
+
+	var projectId string
+	if !model.ProjectId.IsNull() && !model.ProjectId.IsUnknown() {
+		projectId = model.ProjectId.ValueString()
+	} else {
+		if identityData.ProjectID.IsNull() || identityData.ProjectID.IsUnknown() {
+			core.LogAndAddError(ctx, &resp.Diagnostics, functionErrorSummary, "project_id not found in config")
+			return
+		}
+		projectId = identityData.ProjectID.ValueString()
+	}
+
+	var region string
+	if !model.Region.IsNull() && !model.Region.IsUnknown() {
+		region = r.providerData.GetRegionWithOverride(model.Region)
+	} else {
+		if identityData.Region.IsNull() || identityData.Region.IsUnknown() {
+			core.LogAndAddError(ctx, &resp.Diagnostics, functionErrorSummary, "region not found in config")
+			return
+		}
+		region = r.providerData.GetRegionWithOverride(identityData.Region)
+	}
+
+	var instanceId string
+	if !model.InstanceId.IsNull() && !model.InstanceId.IsUnknown() {
+		instanceId = model.InstanceId.ValueString()
+	} else {
+		if identityData.InstanceID.IsNull() || identityData.InstanceID.IsUnknown() {
+			core.LogAndAddError(ctx, &resp.Diagnostics, functionErrorSummary, "instance_id not found in config")
+			return
+		}
+		instanceId = identityData.InstanceID.ValueString()
+	}
+
 	ctx = tflog.SetField(ctx, "project_id", projectId)
 	ctx = tflog.SetField(ctx, "instance_id", instanceId)
 	ctx = tflog.SetField(ctx, "region", region)

-	var storage = storageModel{}
-	if !model.Storage.IsNull() && !model.Storage.IsUnknown() {
-		diags = model.Storage.As(ctx, &storage, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
-	var network = networkModel{}
-	if !model.Network.IsNull() && !model.Network.IsUnknown() {
-		diags = model.Network.As(ctx, &network, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
-	var encryption = encryptionModel{}
-	if !model.Encryption.IsNull() && !model.Encryption.IsUnknown() {
-		diags = model.Encryption.As(ctx, &encryption, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
 	instanceResp, err := r.client.GetInstanceRequest(ctx, projectId, region, instanceId).Execute()
 	if err != nil {
 		oapiErr, ok := err.(*oapierror.GenericOpenAPIError) //nolint:errorlint //complaining that error.As should be used to catch wrapped errors, but this error should not be wrapped
@ -548,21 +344,32 @@ func (r *instanceResource) Read(
 			resp.State.RemoveResource(ctx)
 			return
 		}
-		core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading instance", err.Error())
+		core.LogAndAddError(ctx, &resp.Diagnostics, functionErrorSummary, err.Error())
 		return
 	}

 	ctx = core.LogResponse(ctx)

-	// Map response body to schema
-	err = mapFields(ctx, instanceResp, &model, &storage, &encryption, &network, region)
+	respInstanceID, ok := instanceResp.GetIdOk()
+	if !ok {
+		core.LogAndAddError(ctx, &resp.Diagnostics, functionErrorSummary, "response provided no ID")
+		return
+	}
+	if !model.InstanceId.IsUnknown() && !model.InstanceId.IsNull() {
+		if respInstanceID != instanceId {
+			core.LogAndAddError(
+				ctx,
+				&resp.Diagnostics,
+				functionErrorSummary,
+				"ID in response did not match ID in state",
+			)
+			return
+		}
+	}
+
+	err = mapGetInstanceResponseToModel(ctx, &model, instanceResp)
 	if err != nil {
-		core.LogAndAddError(
-			ctx,
-			&resp.Diagnostics,
-			"Error reading instance",
-			fmt.Sprintf("Processing API payload: %v", err),
-		)
+		core.LogAndAddError(ctx, &resp.Diagnostics, functionErrorSummary, fmt.Sprintf("Processing API payload: %v", err))
 		return
 	}

@ -572,16 +379,24 @@ func (r *instanceResource) Read(
 		return
 	}

+	// Set data returned by API in identity
+	identity := InstanceResourceIdentityModel{
+		ProjectID:  types.StringValue(projectId),
+		Region:     types.StringValue(region),
+		InstanceID: types.StringValue(instanceId),
+	}
+	resp.Diagnostics.Append(resp.Identity.Set(ctx, identity)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
 	tflog.Info(ctx, "Postgres Flex instance read")
 }

 // Update updates the resource and sets the updated Terraform state on success.
-func (r *instanceResource) Update(
-	ctx context.Context,
-	req resource.UpdateRequest,
-	resp *resource.UpdateResponse,
-) { // nolint:gocritic // function signature required by Terraform
-	var model Model
+func (r *instanceResource) Update(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse) { // nolint:gocritic // function signature required by Terraform
+	var model postgresflexalpha.InstanceModel
+
 	diags := req.Plan.Get(ctx, &model)
 	resp.Diagnostics.Append(diags...)
 	if resp.Diagnostics.HasError() {
@ -590,68 +405,70 @@ func (r *instanceResource) Update(

 	ctx = core.InitProviderContext(ctx)

-	projectId := model.ProjectId.ValueString()
-	instanceId := model.InstanceId.ValueString()
+	// Read identity data
+	var identityData InstanceResourceIdentityModel
+	resp.Diagnostics.Append(req.Identity.Get(ctx, &identityData)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	//if model.InstanceId.IsNull() || model.InstanceId.IsUnknown() {
+	//	core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating instance", "instanceId is null or unknown")
+	//	return
+	//}
+	//
+	//if model.ProjectId.IsNull() || model.ProjectId.IsUnknown() {
+	//	core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating instance", "projectId is null or unknown")
+	//	return
+	//}
+
+	//projectId := model.ProjectId.ValueString()
+	//instanceId := model.InstanceId.ValueString()
+	projectId := identityData.ProjectID.ValueString()
+	instanceId := identityData.InstanceID.ValueString()
 	region := model.Region.ValueString()
 	ctx = tflog.SetField(ctx, "project_id", projectId)
 	ctx = tflog.SetField(ctx, "instance_id", instanceId)
 	ctx = tflog.SetField(ctx, "region", region)

-	// nolint:gocritic // need that code later
-	// var acl []string
-	// if !(model.ACL.IsNull() || model.ACL.IsUnknown()) {
-	//	diags = model.ACL.ElementsAs(ctx, &acl, false)
-	//	resp.Diagnostics.Append(diags...)
-	//	if resp.Diagnostics.HasError() {
-	//		return
-	//	}
-	// }
-
-	var storage = &storageModel{}
-	if !model.Storage.IsNull() && !model.Storage.IsUnknown() {
-		diags = model.Storage.As(ctx, storage, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
-	var network = &networkModel{}
-	if !model.Network.IsNull() && !model.Network.IsUnknown() {
-		diags = model.Network.As(ctx, network, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
-	var encryption = &encryptionModel{}
-	if !model.Encryption.IsNull() && !model.Encryption.IsUnknown() {
-		diags = model.Encryption.As(ctx, encryption, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
-	// Generate API request body from model
-	payload, err := toUpdatePayload(&model, storage, network)
-	if err != nil {
-		core.LogAndAddError(
-			ctx,
-			&resp.Diagnostics,
-			"Error updating instance",
-			fmt.Sprintf("Creating API payload: %v", err),
-		)
+	var netAcl []string
+	diag := model.Network.Acl.ElementsAs(ctx, &netAcl, false)
+	resp.Diagnostics.Append(diags...)
+	if diag.HasError() {
 		return
 	}
+
+	if model.Replicas.ValueInt64() > math.MaxInt32 {
+		resp.Diagnostics.AddError("invalid int32 value", "provided int64 value does not fit into int32")
+		return
+	}
+	replInt32 := int32(model.Replicas.ValueInt64()) // nolint:gosec // check is performed above
+
+	payload := postgresflex.UpdateInstanceRequestPayload{
+		BackupSchedule: model.BackupSchedule.ValueStringPointer(),
+		FlavorId:       model.FlavorId.ValueStringPointer(),
+		Name:           model.Name.ValueStringPointer(),
+		Network: &postgresflex.InstanceNetwork{
+			AccessScope: postgresflex.InstanceNetworkGetAccessScopeAttributeType(
+				model.Network.AccessScope.ValueStringPointer(),
+			),
+			Acl: &netAcl,
+		},
+		Replicas:      postgresflex.UpdateInstanceRequestPayloadGetReplicasAttributeType(&replInt32),
+		RetentionDays: model.RetentionDays.ValueInt64Pointer(),
+		Storage: &postgresflex.StorageUpdate{
+			Size: model.Storage.Size.ValueInt64Pointer(),
+		},
+		Version: model.Version.ValueStringPointer(),
+	}
+
 	// Update existing instance
-	err = r.client.UpdateInstancePartiallyRequest(
+	err := r.client.UpdateInstanceRequest(
 		ctx,
 		projectId,
 		region,
 		instanceId,
-	).UpdateInstancePartiallyRequestPayload(*payload).Execute()
+	).UpdateInstanceRequestPayload(payload).Execute()
 	if err != nil {
 		core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating instance", err.Error())
 		return
@ -659,34 +476,18 @@ func (r *instanceResource) Update(

 	ctx = core.LogResponse(ctx)

-	waitResp, err := wait.PartialUpdateInstanceWaitHandler(
-		ctx,
-		r.client,
-		projectId,
-		region,
-		instanceId,
-	).WaitWithContext(ctx)
+	waitResp, err := wait.PartialUpdateInstanceWaitHandler(ctx, r.client, projectId, region, instanceId).WaitWithContext(ctx)
 	if err != nil {
-		core.LogAndAddError(
-			ctx,
-			&resp.Diagnostics,
-			"Error updating instance",
-			fmt.Sprintf("Instance update waiting: %v", err),
-		)
+		core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating instance", fmt.Sprintf("Instance update waiting: %v", err))
 		return
 	}

-	// Map response body to schema
-	err = mapFields(ctx, waitResp, &model, storage, encryption, network, region)
+	err = mapGetInstanceResponseToModel(ctx, &model, waitResp)
 	if err != nil {
-		core.LogAndAddError(
-			ctx,
-			&resp.Diagnostics,
-			"Error updating instance",
-			fmt.Sprintf("Processing API payload: %v", err),
-		)
+		core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating instance", fmt.Sprintf("Processing API payload: %v", err))
 		return
 	}
+
 	diags = resp.State.Set(ctx, model)
 	resp.Diagnostics.Append(diags...)
 	if resp.Diagnostics.HasError() {
@ -696,12 +497,9 @@ func (r *instanceResource) Update(
 }

 // Delete deletes the resource and removes the Terraform state on success.
-func (r *instanceResource) Delete(
-	ctx context.Context,
-	req resource.DeleteRequest,
-	resp *resource.DeleteResponse,
-) { // nolint:gocritic // function signature required by Terraform
-	var model Model
+func (r *instanceResource) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse) { // nolint:gocritic // function signature required by Terraform
+	var model postgresflexalpha.InstanceModel
+
 	diags := req.State.Get(ctx, &model)
 	resp.Diagnostics.Append(diags...)
 	if resp.Diagnostics.HasError() {
@ -740,25 +538,46 @@ func (r *instanceResource) Delete(
 }

 // ImportState imports a resource into the Terraform state on success.
-// The expected format of the resource import identifier is: project_id,instance_id
-func (r *instanceResource) ImportState(
-	ctx context.Context,
-	req resource.ImportStateRequest,
-	resp *resource.ImportStateResponse,
-) {
-	idParts := strings.Split(req.ID, core.Separator)
+// The expected format of the resource import identifier is: project_id,region,instance_id
+func (r *instanceResource) ImportState(ctx context.Context, req resource.ImportStateRequest, resp *resource.ImportStateResponse) {
+	ctx = core.InitProviderContext(ctx)

-	if len(idParts) != 3 || idParts[0] == "" || idParts[1] == "" || idParts[2] == "" {
-		core.LogAndAddError(
-			ctx, &resp.Diagnostics,
-			"Error importing instance",
-			fmt.Sprintf("Expected import identifier with format: [project_id],[region],[instance_id]  Got: %q", req.ID),
-		)
+	if req.ID != "" {
+		idParts := strings.Split(req.ID, core.Separator)
+
+		if len(idParts) != 3 || idParts[0] == "" || idParts[1] == "" || idParts[2] == "" {
+			core.LogAndAddError(ctx, &resp.Diagnostics,
+				"Error importing instance",
+				fmt.Sprintf("Expected import identifier with format: [project_id],[region],[instance_id]  Got: %q", req.ID),
+			)
+			return
+		}
+
+		resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("project_id"), idParts[0])...)
+		resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("region"), idParts[1])...)
+		resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("instance_id"), idParts[2])...)
 		return
 	}

-	resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("project_id"), idParts[0])...)
-	resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("region"), idParts[1])...)
-	resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("instance_id"), idParts[2])...)
+	var identityData InstanceResourceIdentityModel
+	resp.Diagnostics.Append(req.Identity.Get(ctx, &identityData)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	resp.Diagnostics.Append(
+		resp.State.SetAttribute(
+			ctx,
+			path.Root("id"),
+			utils.BuildInternalTerraformId(
+				identityData.ProjectID.ValueString(),
+				identityData.Region.ValueString(),
+				identityData.InstanceID.ValueString(),
+			),
+		)...)
+	resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("project_id"), identityData.ProjectID.ValueString())...)
+	resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("region"), identityData.Region.ValueString())...)
+	resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("instance_id"), identityData.InstanceID.ValueString())...)
+
 	tflog.Info(ctx, "Postgres Flex instance state imported")
 }
--- a/stackit/internal/services/postgresflexalpha/instance/resource_test.go
+++ b/stackit/internal/services/postgresflexalpha/instance/resource_test.go
@ -1,16 +1,10 @@
 package postgresflexalpha

 import (
-	"context"
 	"reflect"
 	"testing"

-	"github.com/google/go-cmp/cmp"
-	"github.com/hashicorp/terraform-plugin-framework/attr"
 	"github.com/hashicorp/terraform-plugin-framework/resource"
-	"github.com/hashicorp/terraform-plugin-framework/types"
-	postgresflex "github.com/mhenselin/terraform-provider-stackitprivatepreview/pkg/postgresflexalpha"
-	"github.com/stackitcloud/stackit-sdk-go/core/utils"
 )

 // type postgresFlexClientMocked struct {
@ -26,608 +20,6 @@ import (
 //	return c.getFlavorsResp, nil
 // }

-func TestMapFields(t *testing.T) {
-	const testRegion = "region"
-	tests := []struct {
-		description string
-		state       Model
-		input       *postgresflex.GetInstanceResponse
-		storage     *storageModel
-		encryption  *encryptionModel
-		network     *networkModel
-		region      string
-		expected    Model
-		isValid     bool
-	}{
-		{
-			"default_values does exactly mean what?",
-			Model{
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Replicas:   types.Int64Value(1),
-			},
-			&postgresflex.GetInstanceResponse{
-				FlavorId: utils.Ptr("flavor_id"),
-				Replicas: postgresflex.GetInstanceResponseGetReplicasAttributeType(utils.Ptr(int32(1))),
-			},
-			&storageModel{},
-			&encryptionModel{},
-			&networkModel{
-				ACL: types.ListValueMust(
-					types.StringType, []attr.Value{
-						types.StringValue("0.0.0.0/0"),
-					},
-				),
-			},
-			testRegion,
-			Model{
-				Id:         types.StringValue("pid,region,iid"),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Name:       types.StringNull(),
-				FlavorId:   types.StringValue("flavor_id"),
-				//ACL:            types.ListNull(types.StringType),
-				BackupSchedule: types.StringNull(),
-				Replicas:       types.Int64Value(1),
-				Encryption: types.ObjectValueMust(
-					encryptionTypes, map[string]attr.Value{
-						"keyring_id":      types.StringNull(),
-						"key_id":          types.StringNull(),
-						"key_version":     types.StringNull(),
-						"service_account": types.StringNull(),
-					},
-				),
-				Storage: types.ObjectValueMust(
-					storageTypes, map[string]attr.Value{
-						"class": types.StringNull(),
-						"size":  types.Int64Null(),
-					},
-				),
-				Network: types.ObjectValueMust(
-					networkTypes, map[string]attr.Value{
-						"acl": types.ListValueMust(
-							types.StringType, []attr.Value{
-								types.StringValue("0.0.0.0/0"),
-							},
-						),
-						"access_scope":     types.StringNull(),
-						"instance_address": types.StringNull(),
-						"router_address":   types.StringNull(),
-					},
-				),
-				Version: types.StringNull(),
-				Region:  types.StringValue(testRegion),
-			},
-			true,
-		},
-		// {
-		//	"acl_unordered",
-		//	Model{
-		//		InstanceId: types.StringValue("iid"),
-		//		ProjectId:  types.StringValue("pid"),
-		//		// ACL: types.ListValueMust(types.StringType, []attr.Value{
-		//		//	types.StringValue("ip2"),
-		//		//	types.StringValue(""),
-		//		//	types.StringValue("ip1"),
-		//		// }),
-		//	},
-		//	&postgresflex.GetInstanceResponse{
-		//		// Acl: &[]string{
-		//		//	"",
-		//		//	"ip1",
-		//		//	"ip2",
-		//		// },
-		//		BackupSchedule: utils.Ptr("schedule"),
-		//		FlavorId:       nil,
-		//		Id:             utils.Ptr("iid"),
-		//		Name:           utils.Ptr("name"),
-		//		Replicas:       postgresflex.GetInstanceResponseGetReplicasAttributeType(utils.Ptr(int32(56))),
-		//		Status:         postgresflex.GetInstanceResponseGetStatusAttributeType(utils.Ptr("status")),
-		//		Storage:        nil,
-		//		Version:        utils.Ptr("version"),
-		//	},
-		//	&flavorModel{
-		//		CPU: types.Int64Value(12),
-		//		RAM: types.Int64Value(34),
-		//	},
-		//	&storageModel{
-		//		Class: types.StringValue("class"),
-		//		Size:  types.Int64Value(78),
-		//	},
-		//	&encryptionModel{},
-		//	&networkModel{},
-		//	testRegion,
-		//	Model{
-		//		Id:         types.StringValue("pid,region,iid"),
-		//		InstanceId: types.StringValue("iid"),
-		//		ProjectId:  types.StringValue("pid"),
-		//		Name:       types.StringValue("name"),
-		//		// ACL: types.ListValueMust(types.StringType, []attr.Value{
-		//		//	types.StringValue("ip2"),
-		//		//	types.StringValue(""),
-		//		//	types.StringValue("ip1"),
-		//		// }),
-		//		BackupSchedule: types.StringValue("schedule"),
-		//		Flavor: types.ObjectValueMust(flavorTypes, map[string]attr.Value{
-		//			"id":          types.StringNull(),
-		//			"description": types.StringNull(),
-		//			"cpu":         types.Int64Value(12),
-		//			"ram":         types.Int64Value(34),
-		//		}),
-		//		Replicas: types.Int64Value(56),
-		//		Storage: types.ObjectValueMust(storageTypes, map[string]attr.Value{
-		//			"class": types.StringValue("class"),
-		//			"size":  types.Int64Value(78),
-		//		}),
-		//		Version: types.StringValue("version"),
-		//		Region:  types.StringValue(testRegion),
-		//	},
-		//	true,
-		// },
-		{
-			"nil_response",
-			Model{
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-			},
-			nil,
-			&storageModel{},
-			&encryptionModel{},
-			&networkModel{},
-			testRegion,
-			Model{},
-			false,
-		},
-		{
-			"no_resource_id",
-			Model{
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-			},
-			&postgresflex.GetInstanceResponse{},
-			&storageModel{},
-			&encryptionModel{},
-			&networkModel{},
-			testRegion,
-			Model{},
-			false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(
-			tt.description, func(t *testing.T) {
-				err := mapFields(
-					context.Background(),
-					tt.input,
-					&tt.state,
-					tt.storage,
-					tt.encryption,
-					tt.network,
-					tt.region,
-				)
-				if !tt.isValid && err == nil {
-					t.Fatalf("Should have failed")
-				}
-				if tt.isValid && err != nil {
-					t.Fatalf("Should not have failed: %v", err)
-				}
-				if tt.isValid {
-					diff := cmp.Diff(tt.expected, tt.state)
-					if diff != "" {
-						t.Fatalf("Data does not match: %s", diff)
-					}
-				}
-			},
-		)
-	}
-}
-
-func TestToCreatePayload(t *testing.T) {
-	tests := []struct {
-		description     string
-		input           *Model
-		inputAcl        []string
-		inputStorage    *storageModel
-		inputEncryption *encryptionModel
-		inputNetwork    *networkModel
-		expected        *postgresflex.CreateInstanceRequestPayload
-		isValid         bool
-	}{
-		{
-			"default_values",
-			&Model{
-				Replicas: types.Int64Value(1),
-			},
-			[]string{},
-			&storageModel{},
-			&encryptionModel{},
-			&networkModel{
-				ACL: types.ListValueMust(
-					types.StringType, []attr.Value{
-						types.StringValue("0.0.0.0/0"),
-					},
-				),
-			},
-			&postgresflex.CreateInstanceRequestPayload{
-				Acl:        &[]string{"0.0.0.0/0"},
-				Storage:    postgresflex.CreateInstanceRequestPayloadGetStorageAttributeType(&postgresflex.Storage{}),
-				Encryption: &postgresflex.InstanceEncryption{},
-				Network: &postgresflex.InstanceNetwork{
-					Acl: &[]string{"0.0.0.0/0"},
-				},
-				Replicas: postgresflex.CreateInstanceRequestPayloadGetReplicasAttributeType(utils.Ptr(int32(1))),
-			},
-			true,
-		},
-		{
-			"nil_model",
-			nil,
-			[]string{},
-			&storageModel{},
-			&encryptionModel{},
-			&networkModel{},
-			nil,
-			false,
-		},
-		{
-			"nil_acl",
-			&Model{},
-			nil,
-			&storageModel{},
-			&encryptionModel{},
-			&networkModel{},
-			nil,
-			false,
-		},
-		{
-			"nil_flavor",
-			&Model{},
-			[]string{},
-			&storageModel{},
-			&encryptionModel{},
-			&networkModel{},
-			nil,
-			false,
-		},
-		{
-			"nil_storage",
-			&Model{},
-			[]string{},
-			nil,
-			&encryptionModel{},
-			&networkModel{},
-			nil,
-			false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(
-			tt.description, func(t *testing.T) {
-				output, err := toCreatePayload(tt.input, tt.inputStorage, tt.inputEncryption, tt.inputNetwork)
-				if !tt.isValid && err == nil {
-					t.Fatalf("Should have failed")
-				}
-				if tt.isValid && err != nil {
-					t.Fatalf("Should not have failed: %v", err)
-				}
-				if tt.isValid {
-					diff := cmp.Diff(tt.expected, output)
-					if diff != "" {
-						t.Fatalf("Data does not match: %s", diff)
-					}
-				}
-			},
-		)
-	}
-}
-
-// func TestToUpdatePayload(t *testing.T) {
-//	tests := []struct {
-//		description  string
-//		input        *Model
-//		inputAcl     []string
-//		inputFlavor  *flavorModel
-//		inputStorage *storageModel
-//		expected     *postgresflex.PartialUpdateInstancePayload
-//		isValid      bool
-//	}{
-//		{
-//			"default_values",
-//			&Model{},
-//			[]string{},
-//			&flavorModel{},
-//			&storageModel{},
-//			&postgresflex.PartialUpdateInstancePayload{
-//				Acl: &postgresflex.ACL{
-//					Items: &[]string{},
-//				},
-//				Storage: &postgresflex.Storage{},
-//			},
-//			true,
-//		},
-//		{
-//			"simple_values",
-//			&Model{
-//				BackupSchedule: types.StringValue("schedule"),
-//				Name:           types.StringValue("name"),
-//				Replicas:       types.Int64Value(12),
-//				Version:        types.StringValue("version"),
-//			},
-//			[]string{
-//				"ip_1",
-//				"ip_2",
-//			},
-//			&flavorModel{
-//				Id: types.StringValue("flavor_id"),
-//			},
-//			&storageModel{
-//				Class: types.StringValue("class"),
-//				Size:  types.Int64Value(34),
-//			},
-//			&postgresflex.PartialUpdateInstancePayload{
-//				Acl: &postgresflex.ACL{
-//					Items: &[]string{
-//						"ip_1",
-//						"ip_2",
-//					},
-//				},
-//				BackupSchedule: utils.Ptr("schedule"),
-//				FlavorId:       utils.Ptr("flavor_id"),
-//				Name:           utils.Ptr("name"),
-//				Replicas:       utils.Ptr(int64(12)),
-//				Storage: &postgresflex.Storage{
-//					Class: utils.Ptr("class"),
-//					Size:  utils.Ptr(int64(34)),
-//				},
-//				Version: utils.Ptr("version"),
-//			},
-//			true,
-//		},
-//		{
-//			"null_fields_and_int_conversions",
-//			&Model{
-//				BackupSchedule: types.StringNull(),
-//				Name:           types.StringNull(),
-//				Replicas:       types.Int64Value(2123456789),
-//				Version:        types.StringNull(),
-//			},
-//			[]string{
-//				"",
-//			},
-//			&flavorModel{
-//				Id: types.StringNull(),
-//			},
-//			&storageModel{
-//				Class: types.StringNull(),
-//				Size:  types.Int64Null(),
-//			},
-//			&postgresflex.PartialUpdateInstancePayload{
-//				Acl: &postgresflex.ACL{
-//					Items: &[]string{
-//						"",
-//					},
-//				},
-//				BackupSchedule: nil,
-//				FlavorId:       nil,
-//				Name:           nil,
-//				Replicas:       utils.Ptr(int64(2123456789)),
-//				Storage: &postgresflex.Storage{
-//					Class: nil,
-//					Size:  nil,
-//				},
-//				Version: nil,
-//			},
-//			true,
-//		},
-//		{
-//			"nil_model",
-//			nil,
-//			[]string{},
-//			&flavorModel{},
-//			&storageModel{},
-//			nil,
-//			false,
-//		},
-//		{
-//			"nil_acl",
-//			&Model{},
-//			nil,
-//			&flavorModel{},
-//			&storageModel{},
-//			nil,
-//			false,
-//		},
-//		{
-//			"nil_flavor",
-//			&Model{},
-//			[]string{},
-//			nil,
-//			&storageModel{},
-//			nil,
-//			false,
-//		},
-//		{
-//			"nil_storage",
-//			&Model{},
-//			[]string{},
-//			&flavorModel{},
-//			nil,
-//			nil,
-//			false,
-//		},
-//	}
-//	for _, tt := range tests {
-//		t.Run(tt.description, func(t *testing.T) {
-//			output, err := toUpdatePayload(tt.input, tt.inputAcl, tt.inputFlavor, tt.inputStorage)
-//			if !tt.isValid && err == nil {
-//				t.Fatalf("Should have failed")
-//			}
-//			if tt.isValid && err != nil {
-//				t.Fatalf("Should not have failed: %v", err)
-//			}
-//			if tt.isValid {
-//				diff := cmp.Diff(output, tt.expected)
-//				if diff != "" {
-//					t.Fatalf("Data does not match: %s", diff)
-//				}
-//			}
-//		})
-//	}
-// }
-//
-// func TestLoadFlavorId(t *testing.T) {
-//	tests := []struct {
-//		description     string
-//		inputFlavor     *flavorModel
-//		mockedResp      *postgresflex.ListFlavorsResponse
-//		expected        *flavorModel
-//		getFlavorsFails bool
-//		isValid         bool
-//	}{
-//		{
-//			"ok_flavor",
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			&postgresflex.ListFlavorsResponse{
-//				Flavors: &[]postgresflex.Flavor{
-//					{
-//						Id:          utils.Ptr("fid-1"),
-//						Cpu:         utils.Ptr(int64(2)),
-//						Description: utils.Ptr("description"),
-//						Ram:      utils.Ptr(int64(8)),
-//					},
-//				},
-//			},
-//			&flavorModel{
-//				Id:          types.StringValue("fid-1"),
-//				Description: types.StringValue("description"),
-//				CPU:         types.Int64Value(2),
-//				RAM:         types.Int64Value(8),
-//			},
-//			false,
-//			true,
-//		},
-//		{
-//			"ok_flavor_2",
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			&postgresflex.ListFlavorsResponse{
-//				Flavors: &[]postgresflex.Flavor{
-//					{
-//						Id:          utils.Ptr("fid-1"),
-//						Cpu:         utils.Ptr(int64(2)),
-//						Description: utils.Ptr("description"),
-//						Ram:      utils.Ptr(int64(8)),
-//					},
-//					{
-//						Id:          utils.Ptr("fid-2"),
-//						Cpu:         utils.Ptr(int64(1)),
-//						Description: utils.Ptr("description"),
-//						Ram:      utils.Ptr(int64(4)),
-//					},
-//				},
-//			},
-//			&flavorModel{
-//				Id:          types.StringValue("fid-1"),
-//				Description: types.StringValue("description"),
-//				CPU:         types.Int64Value(2),
-//				RAM:         types.Int64Value(8),
-//			},
-//			false,
-//			true,
-//		},
-//		{
-//			"no_matching_flavor",
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			&postgresflex.ListFlavorsResponse{
-//				Flavors: &[]postgresflex.Flavor{
-//					{
-//						Id:          utils.Ptr("fid-1"),
-//						Cpu:         utils.Ptr(int64(1)),
-//						Description: utils.Ptr("description"),
-//						Ram:      utils.Ptr(int64(8)),
-//					},
-//					{
-//						Id:          utils.Ptr("fid-2"),
-//						Cpu:         utils.Ptr(int64(1)),
-//						Description: utils.Ptr("description"),
-//						Ram:      utils.Ptr(int64(4)),
-//					},
-//				},
-//			},
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			false,
-//			false,
-//		},
-//		{
-//			"nil_response",
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			&postgresflex.ListFlavorsResponse{},
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			false,
-//			false,
-//		},
-//		{
-//			"error_response",
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			&postgresflex.ListFlavorsResponse{},
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			true,
-//			false,
-//		},
-//	}
-//	for _, tt := range tests {
-//		t.Run(tt.description, func(t *testing.T) {
-//			client := &postgresFlexClientMocked{
-//				returnError:    tt.getFlavorsFails,
-//				getFlavorsResp: tt.mockedResp,
-//			}
-//			model := &Model{
-//				ProjectId: types.StringValue("pid"),
-//			}
-//			flavorModel := &flavorModel{
-//				CPU: tt.inputFlavor.CPU,
-//				RAM: tt.inputFlavor.RAM,
-//			}
-//			err := loadFlavorId(context.Background(), client, model, flavorModel)
-//			if !tt.isValid && err == nil {
-//				t.Fatalf("Should have failed")
-//			}
-//			if tt.isValid && err != nil {
-//				t.Fatalf("Should not have failed: %v", err)
-//			}
-//			if tt.isValid {
-//				diff := cmp.Diff(flavorModel, tt.expected)
-//				if diff != "" {
-//					t.Fatalf("Data does not match: %s", diff)
-//				}
-//			}
-//		})
-//	}
-// }
-
 func TestNewInstanceResource(t *testing.T) {
 	tests := []struct {
 		name string
@ -639,12 +31,10 @@ func TestNewInstanceResource(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
-		t.Run(
-			tt.name, func(t *testing.T) {
-				if got := NewInstanceResource(); !reflect.DeepEqual(got, tt.want) {
-					t.Errorf("NewInstanceResource() = %v, want %v", got, tt.want)
-				}
-			},
-		)
+		t.Run(tt.name, func(t *testing.T) {
+			if got := NewInstanceResource(); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("NewInstanceResource() = %v, want %v", got, tt.want)
+			}
+		})
 	}
 }
--- a/stackit/internal/services/postgresflexalpha/instance/resources_gen/instance_resource_gen.go
+++ b/stackit/internal/services/postgresflexalpha/instance/resources_gen/instance_resource_gen.go
--- a/stackit/internal/services/postgresflexalpha/instance/schema_test.go
+++ b/stackit/internal/services/postgresflexalpha/instance/schema_test.go
@ -0,0 +1,33 @@
+package postgresflexalpha
+
+import (
+	"context"
+	"testing"
+
+	// The fwresource import alias is so there is no collision
+	// with the more typical acceptance testing import:
+	// "github.com/hashicorp/terraform-plugin-testing/helper/resource"
+	fwresource "github.com/hashicorp/terraform-plugin-framework/resource"
+)
+
+func TestInstanceResourceSchema(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	schemaRequest := fwresource.SchemaRequest{}
+	schemaResponse := &fwresource.SchemaResponse{}
+
+	// Instantiate the resource.Resource and call its Schema method
+	NewInstanceResource().Schema(ctx, schemaRequest, schemaResponse)
+
+	if schemaResponse.Diagnostics.HasError() {
+		t.Fatalf("Schema method diagnostics: %+v", schemaResponse.Diagnostics)
+	}
+
+	// Validate the schema
+	diagnostics := schemaResponse.Schema.ValidateImplementation(ctx)
+
+	if diagnostics.HasError() {
+		t.Fatalf("Schema validation diagnostics: %+v", diagnostics)
+	}
+}
--- a/stackit/internal/services/postgresflexalpha/main.go
+++ b/stackit/internal/services/postgresflexalpha/main.go
@ -0,0 +1 @@
+package postgresflexalpha
--- a/stackit/internal/services/postgresflexalpha/postgresflex_acc_test.go
+++ b/stackit/internal/services/postgresflexalpha/postgresflex_acc_test.go
@ -1,9 +1,10 @@
 // Copyright (c) STACKIT

-package postgresflex_test
+package postgresflexalpha_test

 import (
 	"context"
+	_ "embed"
 	"fmt"
 	"strings"
 	"testing"
@ -20,6 +21,11 @@ import (
 	postgresflex "github.com/mhenselin/terraform-provider-stackitprivatepreview/pkg/postgresflexalpha"
 )

+var (
+	//go:embed testdata/resource-complete.tf
+	resourceSecurityGroupMinConfig string //nolint:unused // needs implementation
+)
+
 // Instance resource data
 var instanceResource = map[string]string{
 	"project_id":              testutil.ProjectId,
--- a/stackit/internal/services/postgresflexalpha/role/datasources_gen/roles_data_source_gen.go
+++ b/stackit/internal/services/postgresflexalpha/role/datasources_gen/roles_data_source_gen.go
@ -0,0 +1,52 @@
+// Code generated by terraform-plugin-framework-generator DO NOT EDIT.
+
+package postgresflexalpha
+
+import (
+	"context"
+	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
+	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+)
+
+func RolesDataSourceSchema(ctx context.Context) schema.Schema {
+	return schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"instance_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The ID of the instance.",
+				MarkdownDescription: "The ID of the instance.",
+			},
+			"project_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The STACKIT project ID.",
+				MarkdownDescription: "The STACKIT project ID.",
+			},
+			"region": schema.StringAttribute{
+				Required:            true,
+				Description:         "The region which should be addressed",
+				MarkdownDescription: "The region which should be addressed",
+				Validators: []validator.String{
+					stringvalidator.OneOf(
+						"eu01",
+					),
+				},
+			},
+			"roles": schema.ListAttribute{
+				ElementType:         types.StringType,
+				Computed:            true,
+				Description:         "List of all role names available in the instance",
+				MarkdownDescription: "List of all role names available in the instance",
+			},
+		},
+	}
+}
+
+type RolesModel struct {
+	InstanceId types.String `tfsdk:"instance_id"`
+	ProjectId  types.String `tfsdk:"project_id"`
+	Region     types.String `tfsdk:"region"`
+	Roles      types.List   `tfsdk:"roles"`
+}
--- a/stackit/internal/services/postgresflexalpha/testdata/resource-complete.tf
+++ b/stackit/internal/services/postgresflexalpha/testdata/resource-complete.tf
@ -0,0 +1 @@
+
--- a/stackit/internal/services/postgresflexalpha/user/datasources_gen/user_data_source_gen.go
+++ b/stackit/internal/services/postgresflexalpha/user/datasources_gen/user_data_source_gen.go
@ -0,0 +1,94 @@
+// Code generated by terraform-plugin-framework-generator DO NOT EDIT.
+
+package postgresflexalpha
+
+import (
+	"context"
+	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
+	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+)
+
+func UserDataSourceSchema(ctx context.Context) schema.Schema {
+	return schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"connection_string": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The connection string for the user to the instance.",
+				MarkdownDescription: "The connection string for the user to the instance.",
+			},
+			"host": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The host of the instance in which the user belongs to.",
+				MarkdownDescription: "The host of the instance in which the user belongs to.",
+			},
+			"id": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "The ID of the user.",
+				MarkdownDescription: "The ID of the user.",
+			},
+			"instance_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The ID of the instance.",
+				MarkdownDescription: "The ID of the instance.",
+			},
+			"name": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The name of the user.",
+				MarkdownDescription: "The name of the user.",
+			},
+			"port": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "The port of the instance in which the user belongs to.",
+				MarkdownDescription: "The port of the instance in which the user belongs to.",
+			},
+			"project_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The STACKIT project ID.",
+				MarkdownDescription: "The STACKIT project ID.",
+			},
+			"region": schema.StringAttribute{
+				Required:            true,
+				Description:         "The region which should be addressed",
+				MarkdownDescription: "The region which should be addressed",
+				Validators: []validator.String{
+					stringvalidator.OneOf(
+						"eu01",
+					),
+				},
+			},
+			"roles": schema.ListAttribute{
+				ElementType:         types.StringType,
+				Computed:            true,
+				Description:         "A list of user roles.",
+				MarkdownDescription: "A list of user roles.",
+			},
+			"status": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The current status of the user.",
+				MarkdownDescription: "The current status of the user.",
+			},
+			"user_id": schema.Int64Attribute{
+				Required:            true,
+				Description:         "The ID of the user.",
+				MarkdownDescription: "The ID of the user.",
+			},
+		},
+	}
+}
+
+type UserModel struct {
+	ConnectionString types.String `tfsdk:"connection_string"`
+	Host             types.String `tfsdk:"host"`
+	Id               types.Int64  `tfsdk:"id"`
+	InstanceId       types.String `tfsdk:"instance_id"`
+	Name             types.String `tfsdk:"name"`
+	Port             types.Int64  `tfsdk:"port"`
+	ProjectId        types.String `tfsdk:"project_id"`
+	Region           types.String `tfsdk:"region"`
+	Roles            types.List   `tfsdk:"roles"`
+	Status           types.String `tfsdk:"status"`
+	UserId           types.Int64  `tfsdk:"user_id"`
+}
--- a/stackit/internal/services/postgresflexalpha/user/datasources_gen/users_data_source_gen.go
+++ b/stackit/internal/services/postgresflexalpha/user/datasources_gen/users_data_source_gen.go
--- a/stackit/internal/services/postgresflexalpha/user/resources_gen/user_resource_gen.go
+++ b/stackit/internal/services/postgresflexalpha/user/resources_gen/user_resource_gen.go
@ -0,0 +1,105 @@
+// Code generated by terraform-plugin-framework-generator DO NOT EDIT.
+
+package postgresflexalpha
+
+import (
+	"context"
+	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
+	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema"
+)
+
+func UserResourceSchema(ctx context.Context) schema.Schema {
+	return schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"connection_string": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The connection string for the user to the instance.",
+				MarkdownDescription: "The connection string for the user to the instance.",
+			},
+			"host": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The host of the instance in which the user belongs to.",
+				MarkdownDescription: "The host of the instance in which the user belongs to.",
+			},
+			"id": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "The ID of the user.",
+				MarkdownDescription: "The ID of the user.",
+			},
+			"instance_id": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The ID of the instance.",
+				MarkdownDescription: "The ID of the instance.",
+			},
+			"name": schema.StringAttribute{
+				Required:            true,
+				Description:         "The name of the user.",
+				MarkdownDescription: "The name of the user.",
+			},
+			"password": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The password for the user.",
+				MarkdownDescription: "The password for the user.",
+			},
+			"port": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "The port of the instance in which the user belongs to.",
+				MarkdownDescription: "The port of the instance in which the user belongs to.",
+			},
+			"project_id": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The STACKIT project ID.",
+				MarkdownDescription: "The STACKIT project ID.",
+			},
+			"region": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The region which should be addressed",
+				MarkdownDescription: "The region which should be addressed",
+				Validators: []validator.String{
+					stringvalidator.OneOf(
+						"eu01",
+					),
+				},
+			},
+			"roles": schema.ListAttribute{
+				ElementType:         types.StringType,
+				Optional:            true,
+				Computed:            true,
+				Description:         "A list containing the user roles for the instance.",
+				MarkdownDescription: "A list containing the user roles for the instance.",
+			},
+			"status": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The current status of the user.",
+				MarkdownDescription: "The current status of the user.",
+			},
+			"user_id": schema.Int64Attribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The ID of the user.",
+				MarkdownDescription: "The ID of the user.",
+			},
+		},
+	}
+}
+
+type UserModel struct {
+	ConnectionString types.String `tfsdk:"connection_string"`
+	Host             types.String `tfsdk:"host"`
+	Id               types.Int64  `tfsdk:"id"`
+	InstanceId       types.String `tfsdk:"instance_id"`
+	Name             types.String `tfsdk:"name"`
+	Password         types.String `tfsdk:"password"`
+	Port             types.Int64  `tfsdk:"port"`
+	ProjectId        types.String `tfsdk:"project_id"`
+	Region           types.String `tfsdk:"region"`
+	Roles            types.List   `tfsdk:"roles"`
+	Status           types.String `tfsdk:"status"`
+	UserId           types.Int64  `tfsdk:"user_id"`
+}
--- a/stackit/internal/services/postgresflexalpha/utils/planModifiers.go
+++ b/stackit/internal/services/postgresflexalpha/utils/planModifiers.go
@ -0,0 +1,229 @@
+package utils
+
+import (
+	"fmt"
+	"log/slog"
+	"reflect"
+	"slices"
+
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema/boolplanmodifier"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema/int64planmodifier"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema/listplanmodifier"
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema/stringplanmodifier"
+	"github.com/iancoleman/strcase"
+
+	"gopkg.in/yaml.v3"
+)
+
+type Field struct {
+	Name      string    `yaml:"name"`
+	Modifiers []*string `yaml:"modifiers"`
+}
+
+type Fields struct {
+	Fields []*Field `yaml:"fields"`
+}
+
+var validModifiers = []string{
+	"UseStateForUnknown",
+	"RequiresReplace",
+}
+
+func ReadModifiersConfig(content []byte) (*Fields, error) {
+	var fields Fields
+	err := yaml.Unmarshal(content, &fields)
+	if err != nil {
+		return nil, err
+	}
+	return &fields, nil
+}
+
+func AddPlanModifiersToResourceSchema(fields *Fields, s *schema.Schema) error {
+	err := validateFields(fields)
+	if err != nil {
+		return err
+	}
+
+	resAttr, err := handleAttributes("", s.Attributes, fields)
+	if err != nil {
+		return err
+	}
+	s.Attributes = resAttr
+
+	return nil
+}
+
+func handleAttributes(prefix string, attributes map[string]schema.Attribute, fields *Fields) (map[string]schema.Attribute, error) {
+	fieldMap := fieldListToMap(fields)
+	for attrName, attrValue := range attributes {
+		attrNameSnake := strcase.ToSnake(attrName)
+		if prefix != "" {
+			attrNameSnake = prefix + "." + attrNameSnake
+		}
+		switch reflect.TypeOf(attrValue).String() {
+		case "schema.BoolAttribute":
+			if field, ok := fieldMap[attrNameSnake]; ok {
+				res, err := handleBoolPlanModifiers(attrValue, field)
+				if err != nil {
+					return nil, err
+				}
+				attributes[attrName] = res
+			}
+		case "schema.Int64Attribute":
+			if field, ok := fieldMap[attrNameSnake]; ok {
+				res, err := handleInt64PlanModifiers(attrValue, field)
+				if err != nil {
+					return nil, err
+				}
+				attributes[attrName] = res
+			}
+		case "schema.StringAttribute":
+			if field, ok := fieldMap[attrNameSnake]; ok {
+				res, err := handleStringPlanModifiers(attrValue, field)
+				if err != nil {
+					return nil, err
+				}
+				attributes[attrName] = res
+			}
+		case "schema.ListAttribute":
+			if field, ok := fieldMap[attrNameSnake]; ok {
+				res, err := handleListPlanModifiers(attrValue, field)
+				if err != nil {
+					return nil, err
+				}
+				attributes[attrName] = res
+			}
+		case "schema.SingleNestedAttribute":
+			nested, ok := attrValue.(schema.SingleNestedAttribute)
+			if !ok {
+				if _, ok := attrValue.(interface {
+					GetAttributes() map[string]schema.Attribute
+				}); ok {
+					return nil, fmt.Errorf("unsupported type for single nested attribute")
+				}
+			}
+
+			res, err := handleAttributes(attrName, nested.Attributes, fields)
+			if err != nil {
+				return nil, err
+			}
+			nested.Attributes = res
+			attributes[attrName] = nested
+		default:
+			slog.Warn("type currently not supported", "type", reflect.TypeOf(attrValue).String())
+		}
+	}
+	return attributes, nil
+}
+
+func handleBoolPlanModifiers(
+	attr schema.Attribute,
+	fields []*string,
+) (schema.Attribute, error) {
+	a, ok := attr.(schema.BoolAttribute)
+	if !ok {
+		return nil, fmt.Errorf("field is not a string attribute")
+	}
+
+	for _, v := range fields {
+		switch *v {
+		case "RequiresReplace":
+			a.PlanModifiers = append(a.PlanModifiers, boolplanmodifier.RequiresReplace())
+		case "UseStateForUnknown":
+			a.PlanModifiers = append(a.PlanModifiers, boolplanmodifier.UseStateForUnknown())
+		}
+	}
+	return a, nil
+}
+
+func handleStringPlanModifiers(
+	attr schema.Attribute,
+	fields []*string,
+) (schema.Attribute, error) {
+	a, ok := attr.(schema.StringAttribute)
+	if !ok {
+		return nil, fmt.Errorf("field is not a string attribute")
+	}
+
+	for _, v := range fields {
+		switch *v {
+		case "RequiresReplace":
+			a.PlanModifiers = append(a.PlanModifiers, stringplanmodifier.RequiresReplace())
+		case "UseStateForUnknown":
+			a.PlanModifiers = append(a.PlanModifiers, stringplanmodifier.UseStateForUnknown())
+		}
+	}
+	return a, nil
+}
+
+func handleInt64PlanModifiers(
+	attr schema.Attribute,
+	fields []*string,
+) (schema.Attribute, error) {
+	a, ok := attr.(schema.Int64Attribute)
+	if !ok {
+		return nil, fmt.Errorf("field is not a string attribute")
+	}
+
+	for _, v := range fields {
+		switch *v {
+		case "RequiresReplace":
+			a.PlanModifiers = append(a.PlanModifiers, int64planmodifier.RequiresReplace())
+		case "UseStateForUnknown":
+			a.PlanModifiers = append(a.PlanModifiers, int64planmodifier.UseStateForUnknown())
+		}
+	}
+	return a, nil
+}
+
+func handleListPlanModifiers(
+	attr schema.Attribute,
+	fields []*string,
+) (schema.Attribute, error) {
+	a, ok := attr.(schema.ListAttribute)
+	if !ok {
+		return nil, fmt.Errorf("field is not a string attribute")
+	}
+
+	for _, v := range fields {
+		switch *v {
+		case "RequiresReplace":
+			a.PlanModifiers = append(a.PlanModifiers, listplanmodifier.RequiresReplace())
+		case "UseStateForUnknown":
+			a.PlanModifiers = append(a.PlanModifiers, listplanmodifier.UseStateForUnknown())
+		}
+	}
+	return a, nil
+}
+
+func validateFields(fields *Fields) error {
+	if fields == nil {
+		return nil
+	}
+	for _, field := range fields.Fields {
+		for _, modifier := range field.Modifiers {
+			if *modifier == "" {
+				return fmt.Errorf("modifier %s is required", *modifier)
+			}
+			if !slices.Contains(validModifiers, *modifier) {
+				return fmt.Errorf("modifier %s is invalid", *modifier)
+			}
+		}
+	}
+	return nil
+}
+
+func fieldListToMap(fields *Fields) map[string][]*string {
+	res := make(map[string][]*string)
+
+	if fields != nil {
+		for _, field := range fields.Fields {
+			res[field.Name] = field.Modifiers
+		}
+	} else {
+		slog.Warn("no fields available")
+	}
+
+	return res
+}
--- a/stackit/internal/services/postgresflexalpha/version/datasources_gen/versions_data_source_gen.go
+++ b/stackit/internal/services/postgresflexalpha/version/datasources_gen/versions_data_source_gen.go
@ -0,0 +1,569 @@
+// Code generated by terraform-plugin-framework-generator DO NOT EDIT.
+
+package postgresflexalpha
+
+import (
+	"context"
+	"fmt"
+	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
+	"github.com/hashicorp/terraform-plugin-framework/attr"
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
+	"github.com/hashicorp/terraform-plugin-go/tftypes"
+	"strings"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+)
+
+func VersionsDataSourceSchema(ctx context.Context) schema.Schema {
+	return schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"project_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The STACKIT project ID.",
+				MarkdownDescription: "The STACKIT project ID.",
+			},
+			"region": schema.StringAttribute{
+				Required:            true,
+				Description:         "The region which should be addressed",
+				MarkdownDescription: "The region which should be addressed",
+				Validators: []validator.String{
+					stringvalidator.OneOf(
+						"eu01",
+					),
+				},
+			},
+			"versions": schema.ListNestedAttribute{
+				NestedObject: schema.NestedAttributeObject{
+					Attributes: map[string]schema.Attribute{
+						"beta": schema.BoolAttribute{
+							Computed:            true,
+							Description:         "Flag if the version is a beta version. If set the version may contain bugs and is not fully tested.",
+							MarkdownDescription: "Flag if the version is a beta version. If set the version may contain bugs and is not fully tested.",
+						},
+						"deprecated": schema.StringAttribute{
+							Computed:            true,
+							Description:         "Timestamp in RFC3339 format which says when the version will no longer be supported by STACKIT.",
+							MarkdownDescription: "Timestamp in RFC3339 format which says when the version will no longer be supported by STACKIT.",
+						},
+						"recommend": schema.BoolAttribute{
+							Computed:            true,
+							Description:         "Flag if the version is recommend by the STACKIT Team.",
+							MarkdownDescription: "Flag if the version is recommend by the STACKIT Team.",
+						},
+						"version": schema.StringAttribute{
+							Computed:            true,
+							Description:         "The postgres version used for the instance.",
+							MarkdownDescription: "The postgres version used for the instance.",
+						},
+					},
+					CustomType: VersionsType{
+						ObjectType: types.ObjectType{
+							AttrTypes: VersionsValue{}.AttributeTypes(ctx),
+						},
+					},
+				},
+				Computed:            true,
+				Description:         "A list containing available postgres versions.",
+				MarkdownDescription: "A list containing available postgres versions.",
+			},
+		},
+	}
+}
+
+type VersionsModel struct {
+	ProjectId types.String `tfsdk:"project_id"`
+	Region    types.String `tfsdk:"region"`
+	Versions  types.List   `tfsdk:"versions"`
+}
+
+var _ basetypes.ObjectTypable = VersionsType{}
+
+type VersionsType struct {
+	basetypes.ObjectType
+}
+
+func (t VersionsType) Equal(o attr.Type) bool {
+	other, ok := o.(VersionsType)
+
+	if !ok {
+		return false
+	}
+
+	return t.ObjectType.Equal(other.ObjectType)
+}
+
+func (t VersionsType) String() string {
+	return "VersionsType"
+}
+
+func (t VersionsType) ValueFromObject(ctx context.Context, in basetypes.ObjectValue) (basetypes.ObjectValuable, diag.Diagnostics) {
+	var diags diag.Diagnostics
+
+	attributes := in.Attributes()
+
+	betaAttribute, ok := attributes["beta"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`beta is missing from object`)
+
+		return nil, diags
+	}
+
+	betaVal, ok := betaAttribute.(basetypes.BoolValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`beta expected to be basetypes.BoolValue, was: %T`, betaAttribute))
+	}
+
+	deprecatedAttribute, ok := attributes["deprecated"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`deprecated is missing from object`)
+
+		return nil, diags
+	}
+
+	deprecatedVal, ok := deprecatedAttribute.(basetypes.StringValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`deprecated expected to be basetypes.StringValue, was: %T`, deprecatedAttribute))
+	}
+
+	recommendAttribute, ok := attributes["recommend"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`recommend is missing from object`)
+
+		return nil, diags
+	}
+
+	recommendVal, ok := recommendAttribute.(basetypes.BoolValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`recommend expected to be basetypes.BoolValue, was: %T`, recommendAttribute))
+	}
+
+	versionAttribute, ok := attributes["version"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`version is missing from object`)
+
+		return nil, diags
+	}
+
+	versionVal, ok := versionAttribute.(basetypes.StringValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`version expected to be basetypes.StringValue, was: %T`, versionAttribute))
+	}
+
+	if diags.HasError() {
+		return nil, diags
+	}
+
+	return VersionsValue{
+		Beta:       betaVal,
+		Deprecated: deprecatedVal,
+		Recommend:  recommendVal,
+		Version:    versionVal,
+		state:      attr.ValueStateKnown,
+	}, diags
+}
+
+func NewVersionsValueNull() VersionsValue {
+	return VersionsValue{
+		state: attr.ValueStateNull,
+	}
+}
+
+func NewVersionsValueUnknown() VersionsValue {
+	return VersionsValue{
+		state: attr.ValueStateUnknown,
+	}
+}
+
+func NewVersionsValue(attributeTypes map[string]attr.Type, attributes map[string]attr.Value) (VersionsValue, diag.Diagnostics) {
+	var diags diag.Diagnostics
+
+	// Reference: https://github.com/hashicorp/terraform-plugin-framework/issues/521
+	ctx := context.Background()
+
+	for name, attributeType := range attributeTypes {
+		attribute, ok := attributes[name]
+
+		if !ok {
+			diags.AddError(
+				"Missing VersionsValue Attribute Value",
+				"While creating a VersionsValue value, a missing attribute value was detected. "+
+					"A VersionsValue must contain values for all attributes, even if null or unknown. "+
+					"This is always an issue with the provider and should be reported to the provider developers.\n\n"+
+					fmt.Sprintf("VersionsValue Attribute Name (%s) Expected Type: %s", name, attributeType.String()),
+			)
+
+			continue
+		}
+
+		if !attributeType.Equal(attribute.Type(ctx)) {
+			diags.AddError(
+				"Invalid VersionsValue Attribute Type",
+				"While creating a VersionsValue value, an invalid attribute value was detected. "+
+					"A VersionsValue must use a matching attribute type for the value. "+
+					"This is always an issue with the provider and should be reported to the provider developers.\n\n"+
+					fmt.Sprintf("VersionsValue Attribute Name (%s) Expected Type: %s\n", name, attributeType.String())+
+					fmt.Sprintf("VersionsValue Attribute Name (%s) Given Type: %s", name, attribute.Type(ctx)),
+			)
+		}
+	}
+
+	for name := range attributes {
+		_, ok := attributeTypes[name]
+
+		if !ok {
+			diags.AddError(
+				"Extra VersionsValue Attribute Value",
+				"While creating a VersionsValue value, an extra attribute value was detected. "+
+					"A VersionsValue must not contain values beyond the expected attribute types. "+
+					"This is always an issue with the provider and should be reported to the provider developers.\n\n"+
+					fmt.Sprintf("Extra VersionsValue Attribute Name: %s", name),
+			)
+		}
+	}
+
+	if diags.HasError() {
+		return NewVersionsValueUnknown(), diags
+	}
+
+	betaAttribute, ok := attributes["beta"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`beta is missing from object`)
+
+		return NewVersionsValueUnknown(), diags
+	}
+
+	betaVal, ok := betaAttribute.(basetypes.BoolValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`beta expected to be basetypes.BoolValue, was: %T`, betaAttribute))
+	}
+
+	deprecatedAttribute, ok := attributes["deprecated"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`deprecated is missing from object`)
+
+		return NewVersionsValueUnknown(), diags
+	}
+
+	deprecatedVal, ok := deprecatedAttribute.(basetypes.StringValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`deprecated expected to be basetypes.StringValue, was: %T`, deprecatedAttribute))
+	}
+
+	recommendAttribute, ok := attributes["recommend"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`recommend is missing from object`)
+
+		return NewVersionsValueUnknown(), diags
+	}
+
+	recommendVal, ok := recommendAttribute.(basetypes.BoolValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`recommend expected to be basetypes.BoolValue, was: %T`, recommendAttribute))
+	}
+
+	versionAttribute, ok := attributes["version"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`version is missing from object`)
+
+		return NewVersionsValueUnknown(), diags
+	}
+
+	versionVal, ok := versionAttribute.(basetypes.StringValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`version expected to be basetypes.StringValue, was: %T`, versionAttribute))
+	}
+
+	if diags.HasError() {
+		return NewVersionsValueUnknown(), diags
+	}
+
+	return VersionsValue{
+		Beta:       betaVal,
+		Deprecated: deprecatedVal,
+		Recommend:  recommendVal,
+		Version:    versionVal,
+		state:      attr.ValueStateKnown,
+	}, diags
+}
+
+func NewVersionsValueMust(attributeTypes map[string]attr.Type, attributes map[string]attr.Value) VersionsValue {
+	object, diags := NewVersionsValue(attributeTypes, attributes)
+
+	if diags.HasError() {
+		// This could potentially be added to the diag package.
+		diagsStrings := make([]string, 0, len(diags))
+
+		for _, diagnostic := range diags {
+			diagsStrings = append(diagsStrings, fmt.Sprintf(
+				"%s | %s | %s",
+				diagnostic.Severity(),
+				diagnostic.Summary(),
+				diagnostic.Detail()))
+		}
+
+		panic("NewVersionsValueMust received error(s): " + strings.Join(diagsStrings, "\n"))
+	}
+
+	return object
+}
+
+func (t VersionsType) ValueFromTerraform(ctx context.Context, in tftypes.Value) (attr.Value, error) {
+	if in.Type() == nil {
+		return NewVersionsValueNull(), nil
+	}
+
+	if !in.Type().Equal(t.TerraformType(ctx)) {
+		return nil, fmt.Errorf("expected %s, got %s", t.TerraformType(ctx), in.Type())
+	}
+
+	if !in.IsKnown() {
+		return NewVersionsValueUnknown(), nil
+	}
+
+	if in.IsNull() {
+		return NewVersionsValueNull(), nil
+	}
+
+	attributes := map[string]attr.Value{}
+
+	val := map[string]tftypes.Value{}
+
+	err := in.As(&val)
+
+	if err != nil {
+		return nil, err
+	}
+
+	for k, v := range val {
+		a, err := t.AttrTypes[k].ValueFromTerraform(ctx, v)
+
+		if err != nil {
+			return nil, err
+		}
+
+		attributes[k] = a
+	}
+
+	return NewVersionsValueMust(VersionsValue{}.AttributeTypes(ctx), attributes), nil
+}
+
+func (t VersionsType) ValueType(ctx context.Context) attr.Value {
+	return VersionsValue{}
+}
+
+var _ basetypes.ObjectValuable = VersionsValue{}
+
+type VersionsValue struct {
+	Beta       basetypes.BoolValue   `tfsdk:"beta"`
+	Deprecated basetypes.StringValue `tfsdk:"deprecated"`
+	Recommend  basetypes.BoolValue   `tfsdk:"recommend"`
+	Version    basetypes.StringValue `tfsdk:"version"`
+	state      attr.ValueState
+}
+
+func (v VersionsValue) ToTerraformValue(ctx context.Context) (tftypes.Value, error) {
+	attrTypes := make(map[string]tftypes.Type, 4)
+
+	var val tftypes.Value
+	var err error
+
+	attrTypes["beta"] = basetypes.BoolType{}.TerraformType(ctx)
+	attrTypes["deprecated"] = basetypes.StringType{}.TerraformType(ctx)
+	attrTypes["recommend"] = basetypes.BoolType{}.TerraformType(ctx)
+	attrTypes["version"] = basetypes.StringType{}.TerraformType(ctx)
+
+	objectType := tftypes.Object{AttributeTypes: attrTypes}
+
+	switch v.state {
+	case attr.ValueStateKnown:
+		vals := make(map[string]tftypes.Value, 4)
+
+		val, err = v.Beta.ToTerraformValue(ctx)
+
+		if err != nil {
+			return tftypes.NewValue(objectType, tftypes.UnknownValue), err
+		}
+
+		vals["beta"] = val
+
+		val, err = v.Deprecated.ToTerraformValue(ctx)
+
+		if err != nil {
+			return tftypes.NewValue(objectType, tftypes.UnknownValue), err
+		}
+
+		vals["deprecated"] = val
+
+		val, err = v.Recommend.ToTerraformValue(ctx)
+
+		if err != nil {
+			return tftypes.NewValue(objectType, tftypes.UnknownValue), err
+		}
+
+		vals["recommend"] = val
+
+		val, err = v.Version.ToTerraformValue(ctx)
+
+		if err != nil {
+			return tftypes.NewValue(objectType, tftypes.UnknownValue), err
+		}
+
+		vals["version"] = val
+
+		if err := tftypes.ValidateValue(objectType, vals); err != nil {
+			return tftypes.NewValue(objectType, tftypes.UnknownValue), err
+		}
+
+		return tftypes.NewValue(objectType, vals), nil
+	case attr.ValueStateNull:
+		return tftypes.NewValue(objectType, nil), nil
+	case attr.ValueStateUnknown:
+		return tftypes.NewValue(objectType, tftypes.UnknownValue), nil
+	default:
+		panic(fmt.Sprintf("unhandled Object state in ToTerraformValue: %s", v.state))
+	}
+}
+
+func (v VersionsValue) IsNull() bool {
+	return v.state == attr.ValueStateNull
+}
+
+func (v VersionsValue) IsUnknown() bool {
+	return v.state == attr.ValueStateUnknown
+}
+
+func (v VersionsValue) String() string {
+	return "VersionsValue"
+}
+
+func (v VersionsValue) ToObjectValue(ctx context.Context) (basetypes.ObjectValue, diag.Diagnostics) {
+	var diags diag.Diagnostics
+
+	attributeTypes := map[string]attr.Type{
+		"beta":       basetypes.BoolType{},
+		"deprecated": basetypes.StringType{},
+		"recommend":  basetypes.BoolType{},
+		"version":    basetypes.StringType{},
+	}
+
+	if v.IsNull() {
+		return types.ObjectNull(attributeTypes), diags
+	}
+
+	if v.IsUnknown() {
+		return types.ObjectUnknown(attributeTypes), diags
+	}
+
+	objVal, diags := types.ObjectValue(
+		attributeTypes,
+		map[string]attr.Value{
+			"beta":       v.Beta,
+			"deprecated": v.Deprecated,
+			"recommend":  v.Recommend,
+			"version":    v.Version,
+		})
+
+	return objVal, diags
+}
+
+func (v VersionsValue) Equal(o attr.Value) bool {
+	other, ok := o.(VersionsValue)
+
+	if !ok {
+		return false
+	}
+
+	if v.state != other.state {
+		return false
+	}
+
+	if v.state != attr.ValueStateKnown {
+		return true
+	}
+
+	if !v.Beta.Equal(other.Beta) {
+		return false
+	}
+
+	if !v.Deprecated.Equal(other.Deprecated) {
+		return false
+	}
+
+	if !v.Recommend.Equal(other.Recommend) {
+		return false
+	}
+
+	if !v.Version.Equal(other.Version) {
+		return false
+	}
+
+	return true
+}
+
+func (v VersionsValue) Type(ctx context.Context) attr.Type {
+	return VersionsType{
+		basetypes.ObjectType{
+			AttrTypes: v.AttributeTypes(ctx),
+		},
+	}
+}
+
+func (v VersionsValue) AttributeTypes(ctx context.Context) map[string]attr.Type {
+	return map[string]attr.Type{
+		"beta":       basetypes.BoolType{},
+		"deprecated": basetypes.StringType{},
+		"recommend":  basetypes.BoolType{},
+		"version":    basetypes.StringType{},
+	}
+}