Custom types

schema.StringAttribute{
    CustomType: CustomStringType{},
    // ... other fields ...
}

type ThingModel struct {
    // Instead of types.String
    Timestamp CustomStringValue `tfsdk:"timestamp"`
    // ... other fields ...
}

import (
    "context"
    "fmt"

    "github.com/hashicorp/terraform-plugin-framework/attr"
    "github.com/hashicorp/terraform-plugin-framework/diag"
    "github.com/hashicorp/terraform-plugin-framework/types/basetypes"
    "github.com/hashicorp/terraform-plugin-go/tftypes"
)

// Ensure the implementation satisfies the expected interfaces
var _ basetypes.StringTypable = CustomStringType{}

type CustomStringType struct {
    basetypes.StringType
    // ... potentially other fields ...
}

func (t CustomStringType) Equal(o attr.Type) bool {
    other, ok := o.(CustomStringType)

    if !ok {
        return false
    }

    return t.StringType.Equal(other.StringType)
}

func (t CustomStringType) String() string {
    return "CustomStringType"
}

func (t CustomStringType) ValueFromString(ctx context.Context, in basetypes.StringValue) (basetypes.StringValuable, diag.Diagnostics) {
    // CustomStringValue defined in the value type section
    value := CustomStringValue{
        StringValue: in,
    }

    return value, nil
}

func (t CustomStringType) ValueFromTerraform(ctx context.Context, in tftypes.Value) (attr.Value, error) {
    attrValue, err := t.StringType.ValueFromTerraform(ctx, in)

    if err != nil {
        return nil, err
    }

    stringValue, ok := attrValue.(basetypes.StringValue)

    if !ok {
        return nil, fmt.Errorf("unexpected value type of %T", attrValue)
    }

    stringValuable, diags := t.ValueFromString(ctx, stringValue)

    if diags.HasError() {
        return nil, fmt.Errorf("unexpected error converting StringValue to StringValuable: %v", diags)
    }

    return stringValuable, nil
}

func (t CustomStringType) ValueType(ctx context.Context) attr.Value {
    // CustomStringValue defined in the value type section
    return CustomStringValue{}
}

import (
    "context"
    "fmt"

    "github.com/hashicorp/terraform-plugin-framework/attr"
    "github.com/hashicorp/terraform-plugin-framework/diag"
    "github.com/hashicorp/terraform-plugin-framework/types/basetypes"
    "github.com/hashicorp/terraform-plugin-go/tftypes"
)

// Ensure the implementation satisfies the expected interfaces
var _ basetypes.StringValuable = CustomStringValue{}

type CustomStringValue struct {
    basetypes.StringValue
    // ... potentially other fields ...
}

func (v CustomStringValue) Equal(o attr.Value) bool {
    other, ok := o.(CustomStringValue)

    if !ok {
        return false
    }

    return v.StringValue.Equal(other.StringValue)
}

func (v CustomStringValue) Type(ctx context.Context) attr.Type {
    // CustomStringType defined in the schema type section
    return CustomStringType{}
}

// CustomStringValue defined in the value type section
// Ensure the implementation satisfies the expected interfaces
var _ basetypes.StringValuableWithSemanticEquals = CustomStringValue{}

func (v CustomStringValue) StringSemanticEquals(ctx context.Context, newValuable basetypes.StringValuable) (bool, diag.Diagnostics) {
    var diags diag.Diagnostics

    // The framework should always pass the correct value type, but always check
    newValue, ok := newValuable.(CustomStringValue)

    if !ok {
        diags.AddError(
            "Semantic Equality Check Error",
            "An unexpected value type was received while performing semantic equality checks. "+
            "Please report this to the provider developers.\n\n"+
            "Expected Value Type: "+fmt.Sprintf("%T", v)+"\n"+
            "Got Value Type: "+fmt.Sprintf("%T", newValuable),
        )

        return false, diags
    }

    // Skipping error checking if CustomStringValue already implemented RFC3339 validation
    priorTime, _ := time.Parse(time.RFC3339, v.StringValue.ValueString())

    // Skipping error checking if CustomStringValue already implemented RFC3339 validation
    newTime, _ := time.Parse(time.RFC3339, newValue.ValueString())

    // If the times are equivalent, keep the prior value
    return priorTime.Equal(newTime), diags
}

// Implementation of the xattr.ValidateableAttribute interface
func (v CustomStringValue) ValidateAttribute(ctx context.Context, req xattr.ValidateAttributeRequest, resp *xattr.ValidateAttributeResponse) {
    if v.IsNull() || v.IsUnknown() {
        return
    }

    err := v.validate(v.ValueString())

    if err != nil {
        resp.Diagnostics.AddAttributeError(
            req.Path,
            "Invalid RFC 3339 String Value",
            "An unexpected error occurred while converting a string value that was expected to be RFC 3339 format. "+
                "The RFC 3339 string format is YYYY-MM-DDTHH:MM:SSZ, such as 2006-01-02T15:04:05Z or 2006-01-02T15:04:05+07:00.\n\n"+
                "Path: "+req.Path.String()+"\n"+
                "Given Value: "+v.ValueString()+"\n"+
                "Error: "+err.Error(),
        )

        return
    }
}

// Implementation of the function.ValidateableParameter interface
func (v CustomStringValue) ValidateParameter(ctx context.Context, req function.ValidateParameterRequest, resp *function.ValidateParameterResponse) {
    if v.IsNull() || v.IsUnknown() {
        return
    }

    err := v.validate(v.ValueString())

    if err != nil {
        resp.Error = function.NewArgumentFuncError(
            req.Position,
            "Invalid RFC 3339 String Value: "+
                "An unexpected error occurred while converting a string value that was expected to be RFC 3339 format. "+
                "The RFC 3339 string format is YYYY-MM-DDTHH:MM:SSZ, such as 2006-01-02T15:04:05Z or 2006-01-02T15:04:05+07:00.\n\n"+
                fmt.Sprintf("Position: %d", req.Position)+"\n"+
                "Given Value: "+v.ValueString()+"\n"+
                "Error: "+err.Error(),
        )
    }
}

func (v CustomStringValue) validate(in string) error {
    _, err := time.Parse(time.RFC3339, in)

    return err
}

// CustomStringType defined in the schema type section
func (t CustomStringType) Validate(ctx context.Context, value tftypes.Value, valuePath path.Path) diag.Diagnostics {
    if value.IsNull() || !value.IsKnown() {
        return nil
    }

    var diags diag.Diagnostics
    var valueString string

    if err := value.As(&valueString); err != nil {
        diags.AddAttributeError(
            valuePath,
            "Invalid Terraform Value",
            "An unexpected error occurred while attempting to convert a Terraform value to a string. "+
                "This generally is an issue with the provider schema implementation. "+
                "Please contact the provider developers.\n\n"+
                "Path: "+valuePath.String()+"\n"+
                "Error: "+err.Error(),
        )

        return diags
    }

    if _, err := time.Parse(time.RFC3339, valueString); err != nil {
        diags.AddAttributeError(
            valuePath,
            "Invalid RFC 3339 String Value",
            "An unexpected error occurred while converting a string value that was expected to be RFC 3339 format. "+
                "The RFC 3339 string format is YYYY-MM-DDTHH:MM:SSZ, such as 2006-01-02T15:04:05Z or 2006-01-02T15:04:05+07:00.\n\n"+
                "Path: "+valuePath.String()+"\n"+
                "Given Value: "+valueString+"\n"+
                "Error: "+err.Error(),
        )

        return diags
    }

    return diags
}