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/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)
+	}
+}