func ImportStatePassthroughID(ctxcontext.Context, attrPathpath.Path, reqImportStateRequest, resp *ImportStateResponse)

func ImportStatePassthroughWithIdentity(ctxcontext.Context, stateAttrPath, identityAttrPathpath.Path, reqImportStateRequest, resp *ImportStateResponse)

type ConfigValidator interface {// Description describes the validation in plain text formatting.//// This information may be automatically added to resource plain text// descriptions by external tooling.Description(context.Context)string// MarkdownDescription describes the validation in Markdown formatting.//// This information may be automatically added to resource Markdown// descriptions by external tooling.MarkdownDescription(context.Context)string// ValidateResource performs the validation.//// This method name is separate from ConfigValidators in datasource and other packages in// order to allow generic validators.ValidateResource(context.Context,ValidateConfigRequest, *ValidateConfigResponse)}

type ConfigureRequest struct {// ProviderData is the data set in the// [provider.ConfigureResponse.ResourceData] field. This data is// provider-specifc and therefore can contain any necessary remote system// clients, custom provider data, or anything else pertinent to the// functionality of the Resource.//// This data is only set after the ConfigureProvider RPC has been called// by Terraform.ProviderDataany}

type ConfigureResponse struct {// Diagnostics report errors or warnings related to configuring of the// Datasource. An empty slice indicates a successful operation with no// warnings or errors generated.Diagnosticsdiag.Diagnostics}

type CreateRequest struct {// Config is the configuration the user supplied for the resource.//// This configuration may contain unknown values if a user uses// interpolation or other functionality that would prevent Terraform// from knowing the value at request time.Configtfsdk.Config// Plan is the planned state for the resource.Plantfsdk.Plan// Identity is the planned identity for the resource. If the resource does not// support identity, this value will not be set.Identity *tfsdk.ResourceIdentity// ProviderMeta is metadata from the provider_meta block of the module.ProviderMetatfsdk.Config}

type CreateResponse struct {// State is the state of the resource following the Create operation.// This field is pre-populated from CreateRequest.Plan and// should be set during the resource's Create operation.Statetfsdk.State// Identity is the identity of the resource following the Create operation.// This field is pre-populated from CreateRequest.Identity and// should be set during the resource's Create operation.//// If the resource does not support identity, this value will not be set and will// raise a diagnostic if set by the resource's Create operation.Identity *tfsdk.ResourceIdentity// Private is the private state resource data following the Create operation.// This field is not pre-populated as there is no pre-existing private state// data during the resource's Create operation.Private *privatestate.ProviderData// Diagnostics report errors or warnings related to creating the// resource. An empty slice indicates a successful operation with no// warnings or errors generated.Diagnosticsdiag.Diagnostics}

type Deferred struct {// Reason is the reason for deferring the change.ReasonDeferredReason}

type DeferredReasonint32

func (DeferredReason)String¶added inv1.9.0

func (dDeferredReason) String()string

type DeleteRequest struct {// State is the current state of the resource prior to the Delete// operation.Statetfsdk.State// Identity is the current identity of the resource prior to the Delete// operation. If the resource does not support identity, this value will not be set.Identity *tfsdk.ResourceIdentity// ProviderMeta is metadata from the provider_meta block of the module.ProviderMetatfsdk.Config// Private is provider-defined resource private state data which was previously// stored with the resource state.//// Use the GetKey method to read data.Private *privatestate.ProviderData}

type DeleteResponse struct {// State is the state of the resource following the Delete operation.// This field is pre-populated from DeleteRequest.State and// should be set during the resource's Delete operation.Statetfsdk.State// Identity is the identity of the resource following the Delete operation.Identity *tfsdk.ResourceIdentity// Private is the private state resource data following the Delete// operation. This field is pre-populated from DeleteRequest.Private and// can be modified during the resource's Delete operation in cases where// an error diagnostic is being returned. Otherwise if no error diagnostic// is being returned, indicating that the resource was successfully deleted,// this data will be automatically cleared to prevent Terraform errors.Private *privatestate.ProviderData// Diagnostics report errors or warnings related to deleting the// resource. An empty slice indicates a successful operation with no// warnings or errors generated.Diagnosticsdiag.Diagnostics}

type IdentitySchemaRequest struct{}

type IdentitySchemaResponse struct {// IdentitySchema is the schema of the resource identity.IdentitySchemaidentityschema.Schema// Diagnostics report errors or warnings related to retrieving the resource// identity schema. An empty slice indicates success, with no warnings// or errors generated.Diagnosticsdiag.Diagnostics}

type IdentityUpgrader struct {// Schema information for the prior identity version. While not required,// setting this will populate the UpgradeIdentityRequest type Identity// field similar to other Resource data types. This allows for easier data// handling such as calling Get() or GetAttribute().//// If not set, prior identity data is available in the// UpgradeIdentityRequest type RawIdentity field.PriorSchema *identityschema.Schema// Provider defined logic for upgrading a resource identity from the prior// identity version to the current schema version.//// The context.Context parameter contains framework-defined loggers and// supports request cancellation.//// The UpgradeIdentityRequest parameter contains the prior identity data.// If PriorSchema was set, the Identity field will be available. Otherwise,// the RawIdentity must be used.//// The UpgradeIdentityResponse parameter should contain the upgraded// identity data and can be used to signal any logic warnings or errors.IdentityUpgrader func(context.Context,UpgradeIdentityRequest, *UpgradeIdentityResponse)}

type ImportStateClientCapabilities struct {// DeferralAllowed indicates whether the Terraform client initiating// the request allows a deferral response.//// NOTE: This functionality is related to deferred action support, which is currently experimental and is subject// to change or break without warning. It is not protected by version compatibility guarantees.DeferralAllowedbool}

type ImportStateRequest struct {// ID represents the import identifier supplied by the practitioner when// calling the import command. In many cases, this may align with the// unique identifier for the resource, which can optionally be stored// as an Attribute. However, this identifier can also be treated as// its own type of value and parsed during import. This value// is not stored in the state unless the provider explicitly stores it.//// This ID field is supplied in the "terraform import" CLI command or in the import config block "id" attribute.// Either ID or Identity must be supplied by the practitioner, depending on the method used to import the resource.IDstring// Identity is the configuration data provided by the practitioner in the import config block "identity" attribute. This// configuration data will conform to the identity schema defined by the managed resource. If the resource does not support identity,// this value will not be set.//// The "identity" attribute in the import block is only supported in Terraform 1.12 and later.// Either ID or Identity must be supplied by the practitioner, depending on the method used to import the resource.Identity *tfsdk.ResourceIdentity// ClientCapabilities defines optionally supported protocol features for the// ImportResourceState RPC, such as forward-compatible Terraform behavior changes.ClientCapabilitiesImportStateClientCapabilities}

type ImportStateResponse struct {// Diagnostics report errors or warnings related to importing the// resource. An empty slice indicates a successful operation with no// warnings or errors generated.Diagnosticsdiag.Diagnostics// State is the state of the resource following the import operation.// It must contain enough information so Terraform can successfully// refresh the resource, e.g. call the Resource Read method.Statetfsdk.State// Identity is the identity of the resource following the Import operation.// This field is pre-populated from ImportStateRequest.Identity and// should be set during the resource's Import operation.//// If the resource does not support identity, this value will not be set and will// raise a diagnostic if set by the resource's Import operation.Identity *tfsdk.ResourceIdentity// Private is the private state resource data following the Import operation.// This field is not pre-populated as there is no pre-existing private state// data during the resource's Import operation.Private *privatestate.ProviderData// Deferred indicates that Terraform should defer// importing this resource.//// This field can only be set if// `(resource.ImportStateRequest).ClientCapabilities.DeferralAllowed` is true.//// NOTE: This functionality is related to deferred action support, which is currently experimental and is subject// to change or break without warning. It is not protected by version compatibility guarantees.Deferred *Deferred}

type MetadataRequest struct {// ProviderTypeName is the string returned from// [provider.MetadataResponse.TypeName], if the Provider type implements// the Metadata method. This string should prefix the Resource type name// with an underscore in the response.ProviderTypeNamestring}

type MetadataResponse struct {// TypeName should be the full resource type, including the provider// type prefix and an underscore. For example, examplecloud_thing.TypeNamestring// ResourceBehavior is used to control framework-specific logic when// interacting with this resource.ResourceBehaviorResourceBehavior}

type ModifyPlanClientCapabilities struct {// DeferralAllowed indicates whether the Terraform client initiating// the request allows a deferral response.//// NOTE: This functionality is related to deferred action support, which is currently experimental and is subject// to change or break without warning. It is not protected by version compatibility guarantees.DeferralAllowedbool}

type ModifyPlanRequest struct {// Config is the configuration the user supplied for the resource.//// This configuration may contain unknown values if a user uses// interpolation or other functionality that would prevent Terraform// from knowing the value at request time.Configtfsdk.Config// State is the current state of the resource.Statetfsdk.State// Identity is the current identity of the resource. If the resource does not// support identity, this value will not be set.Identity *tfsdk.ResourceIdentity// Plan is the planned new state for the resource. Terraform 1.3 and later// supports resource destroy planning, in which this will contain a null// value.Plantfsdk.Plan// ProviderMeta is metadata from the provider_meta block of the module.ProviderMetatfsdk.Config// Private is provider-defined resource private state data which was previously// stored with the resource state. This data is opaque to Terraform and does// not affect plan output. Any existing data is copied to// ModifyPlanResponse.Private to prevent accidental private state data loss.//// Use the GetKey method to read data. Use the SetKey method on// ModifyPlanResponse.Private to update or remove a value.Private *privatestate.ProviderData// ClientCapabilities defines optionally supported protocol features for the// PlanResourceChange RPC, such as forward-compatible Terraform behavior changes.ClientCapabilitiesModifyPlanClientCapabilities}

type ModifyPlanResponse struct {// Plan is the planned new state for the resource.Plantfsdk.Plan// Identity is the planned new identity of the resource.// This field is pre-populated from ModifyPlanRequest.Identity.//// If the resource does not support identity, this value will not be set and will// raise a diagnostic if set.Identity *tfsdk.ResourceIdentity// RequiresReplace is a list of attribute paths that require the// resource to be replaced. They should point to the specific field// that changed that requires the resource to be destroyed and// recreated.RequiresReplacepath.Paths// Private is the private state resource data following the ModifyPlan operation.// This field is pre-populated from ModifyPlanRequest.Private and// can be modified during the resource's ModifyPlan operation.Private *privatestate.ProviderData// Diagnostics report errors or warnings related to determining the// planned state of the requested resource. Returning an empty slice// indicates a successful plan modification with no warnings or errors// generated.Diagnosticsdiag.Diagnostics// Deferred indicates that Terraform should defer importing this// resource until a followup apply operation.//// This field can only be set if// `(resource.ModifyPlanRequest).ClientCapabilities.DeferralAllowed` is true.//// NOTE: This functionality is related to deferred action support, which is currently experimental and is subject// to change or break without warning. It is not protected by version compatibility guarantees.Deferred *Deferred}

type MoveStateRequest struct {// SourcePrivate is the source resource private state data. If this source// data is important for the target resource, the implementation should set// the data via [MoveStateResponse.TargetPrivate] as it is intentionally not// copied automatically.SourcePrivate *privatestate.ProviderData// SourceProviderAddress is the address of the provider for the source// resource type. It is the full address in HOSTNAME/NAMESPACE/TYPE format.// For example, registry.terraform.io/hashicorp/random.//// Implementations should consider using this value to determine whether the// request should be handled by this particular implementation. It is// recommended to ignore the hostname unless necessary for disambiguation.SourceProviderAddressstring// SourceRawState is the raw state of the source resource. This data is// always available, regardless whether the [StateMover.SourceSchema] field// was set. If SourceSchema is present, the [SourceState] field will be// populated and it is recommended to use that field instead.//// If this request matches the intended implementation, the implementation// logic must set [MoveStateResponse.State] as it is intentionally not// copied automatically.//// This is advanced functionality for providers wanting to skip the full// redeclaration of source schemas and instead use lower level handlers to// transform data. A typical implementation for working with this data will// call the Unmarshal() method.SourceRawState *tfprotov6.RawState// SourceSchemaVersion is the schema version of the source resource. It is// important for implementations to account for the schema version when// handling the source state data, since differing schema versions typically// have differing data structures and types.SourceSchemaVersionint64// SourceState is the source resource state if the [StateMover.SourceSchema]// was set. When available, this allows for easier data handling such as// calling Get() or GetAttribute().//// If this request matches the intended implementation, the implementation// logic must set [MoveStateResponse.TargetState] as it is intentionally not// copied automatically.//// State conversion errors based on [StateMover.SourceSchema] not matching// the source state are only intentionally logged at DEBUG level as there// may be multiple [StateMover] implementations on the same target resource// for differing source resources. The [StateMover] implementation will// still be called even with these errors, so it is important that// implementations verify the request via the SourceTypeName and other// fields before attempting to use this data.SourceState *tfsdk.State// SourceTypeName is the type name of the source resource. For example,// aws_vpc or random_string.//// Implementations should always use this value, in addition to potentially// other request fields, to determine whether the request should be handled// by this particular implementation.SourceTypeNamestring// SourceIdentity is the identity of the source resource.//// Only the underlying JSON field is populated.SourceIdentity *tfprotov6.RawState// SourceIdentitySchemaVersion is the version of the source resource identity.SourceIdentitySchemaVersionint64}

type MoveStateResponse struct {// Diagnostics report errors or warnings related to moving the resource.// An unset or empty value indicates a successful operation or skipped// implementation if [TargetState] is also not set.Diagnosticsdiag.Diagnostics// TargetState is the resource state following the move operation. This// value is intentionally not pre-populated by the framework. The provider// must set state values to indicate a successful move operation.//// If this value is unset and there are no diagnostics, the framework will// consider this implementation to have not matched the request and move on// to the next implementation, if any. If no implementation returns a state// then the framework will return an implementation not found error.TargetStatetfsdk.State// TargetPrivate is the resource private state data following the move// operation. This field is not pre-populated as it is up to implementations// whether the source private data is relevant for the target resource.TargetPrivate *privatestate.ProviderData// TargetIdentity is the identity of the target resource.TargetIdentity *tfsdk.ResourceIdentity}

type ProviderDeferredBehavior struct {// When EnablePlanModification is true, framework will still execute// provider-defined resource plan modification logic if// provider.Configure defers. Framework will then automatically return a// deferred response along with the modified plan.EnablePlanModificationbool}

type ReadClientCapabilities struct {// DeferralAllowed indicates whether the Terraform client initiating// the request allows a deferral response.//// NOTE: This functionality is related to deferred action support, which is currently experimental and is subject// to change or break without warning. It is not protected by version compatibility guarantees.DeferralAllowedbool}

type ReadRequest struct {// State is the current state of the resource prior to the Read// operation.Statetfsdk.State// Identity is the current identity of the resource prior to the Read// operation. If the resource does not support identity, this value will not be set.Identity *tfsdk.ResourceIdentity// Private is provider-defined resource private state data which was previously// stored with the resource state. This data is opaque to Terraform and does// not affect plan output. Any existing data is copied to// ReadResourceResponse.Private to prevent accidental private state data loss.//// Use the GetKey method to read data. Use the SetKey method on// ReadResourceResponse.Private to update or remove a value.Private *privatestate.ProviderData// ProviderMeta is metadata from the provider_meta block of the module.ProviderMetatfsdk.Config// ClientCapabilities defines optionally supported protocol features for the// ReadResource RPC, such as forward-compatible Terraform behavior changes.ClientCapabilitiesReadClientCapabilities}

type ReadResponse struct {// State is the state of the resource following the Read operation.// This field is pre-populated from ReadRequest.State and// should be set during the resource's Read operation.Statetfsdk.State// Identity is the identity of the resource following the Read operation.// This field is pre-populated from ReadRequest.Identity and// should be set during the resource's Read operation.//// If the resource does not support identity, this value will not be set and will// raise a diagnostic if set by the resource's Read operation.Identity *tfsdk.ResourceIdentity// Private is the private state resource data following the Read operation.// This field is pre-populated from ReadResourceRequest.Private and// can be modified during the resource's Read operation.Private *privatestate.ProviderData// Diagnostics report errors or warnings related to reading the// resource. An empty slice indicates a successful operation with no// warnings or errors generated.Diagnosticsdiag.Diagnostics// Deferred indicates that Terraform should defer refreshing this// resource until a followup plan operation.//// This field can only be set if// `(resource.ReadRequest).ClientCapabilities.DeferralAllowed` is true.//// NOTE: This functionality is related to deferred action support, which is currently experimental and is subject// to change or break without warning. It is not protected by version compatibility guarantees.Deferred *Deferred}

type Resource interface {// Metadata should return the full name of the resource, such as// examplecloud_thing.Metadata(context.Context,MetadataRequest, *MetadataResponse)// Schema should return the schema for this resource.Schema(context.Context,SchemaRequest, *SchemaResponse)// Create is called when the provider must create a new resource. Config// and planned state values should be read from the// CreateRequest and new state values set on the CreateResponse.Create(context.Context,CreateRequest, *CreateResponse)// Read is called when the provider must read resource values in order// to update state. Planned state values should be read from the// ReadRequest and new state values set on the ReadResponse.Read(context.Context,ReadRequest, *ReadResponse)// Update is called to update the state of the resource. Config, planned// state, and prior state values should be read from the// UpdateRequest and new state values set on the UpdateResponse.Update(context.Context,UpdateRequest, *UpdateResponse)// Delete is called when the provider must delete the resource. Config// values may be read from the DeleteRequest.//// If execution completes without error, the framework will automatically// call DeleteResponse.State.RemoveResource(), so it can be omitted// from provider logic.Delete(context.Context,DeleteRequest, *DeleteResponse)}

type ResourceBehavior struct {// ProviderDeferred enables provider-defined logic to be executed// in the case of an automatic deferred response from provider configure.//// NOTE: This functionality is related to deferred action support, which is currently experimental and is subject// to change or break without warning. It is not protected by version compatibility guarantees.ProviderDeferredProviderDeferredBehavior// MutableIdentity indicates that the managed resource supports an identity that can change during the// resource's lifecycle. Setting this flag to true will disable the SDK validation that ensures identity// data doesn't change during RPC calls.MutableIdentitybool}

type ResourceWithConfigValidators interface {Resource// ConfigValidators returns a list of functions which will all be performed during validation.ConfigValidators(context.Context) []ConfigValidator}

type ResourceWithConfigure interface {Resource// Configure enables provider-level data or clients to be set in the// provider-defined Resource type. It is separately executed for each// ReadResource RPC.Configure(context.Context,ConfigureRequest, *ConfigureResponse)}

type ResourceWithIdentity interface {Resource// IdentitySchema should return the identity schema for this resource.IdentitySchema(context.Context,IdentitySchemaRequest, *IdentitySchemaResponse)}

type ResourceWithImportState interface {Resource// ImportState is called when the provider must import the state of a// resource instance. This method must return enough state so the Read// method can properly refresh the full resource.//// If setting an attribute with the import identifier, it is recommended// to use the ImportStatePassthroughID() call in this method.ImportState(context.Context,ImportStateRequest, *ImportStateResponse)}

type ResourceWithModifyPlan interface {Resource// ModifyPlan is called when the provider has an opportunity to modify// the plan: once during the plan phase when Terraform is determining// the diff that should be shown to the user for approval, and once// during the apply phase with any unknown values from configuration// filled in with their final values.//// The planned new state is represented by// ModifyPlanResponse.Plan. It must meet the following// constraints:// 1. Any non-Computed attribute set in config must preserve the exact// config value or return the corresponding attribute value from the// prior state (ModifyPlanRequest.State).// 2. Any attribute with a known value must not have its value changed// in subsequent calls to ModifyPlan or Create/Read/Update.// 3. Any attribute with an unknown value may either remain unknown// or take on any value of the expected type.//// Any errors will prevent further resource-level plan modifications.ModifyPlan(context.Context,ModifyPlanRequest, *ModifyPlanResponse)}

type ResourceWithMoveState interface {Resource// An ordered list of source resource to current schema version state move// implementations. Only the first [StateMover] implementation that returns// state data or error diagnostics will be used, otherwise the framework// considers the [StateMover] as skipped and will try the next [StateMover].// If all implementations return without state and error diagnostics, the// framework will return an implementation not found error.//// It is strongly recommended that implementations be overly cautious and// return no state data if the source provider address, resource type,// or schema version is not fully implemented.MoveState(context.Context) []StateMover}

type ResourceWithUpgradeIdentity interface {Resource// A mapping of the prior identity version to current identity upgrade// implementation. Only the specified identity upgrader for the prior identity// version is called, rather than each version in between, so it must// encapsulate all logic to convert the prior identity to the current identity schema// version.//// Version keys begin at 0, which is the default schema version when// undefined. The framework will return an error diagnostic should the// requested identity version not be implemented.UpgradeIdentity(context.Context) map[int64]IdentityUpgrader}

type ResourceWithUpgradeState interface {Resource// A mapping of prior state version to current schema version state upgrade// implementations. Only the specified state upgrader for the prior state// version is called, rather than each version in between, so it must// encapsulate all logic to convert the prior state to the current schema// version.//// Version keys begin at 0, which is the default schema version when// undefined. The framework will return an error diagnostic should the// requested state version not be implemented.UpgradeState(context.Context) map[int64]StateUpgrader}

type ResourceWithValidateConfig interface {Resource// ValidateConfig performs the validation.ValidateConfig(context.Context,ValidateConfigRequest, *ValidateConfigResponse)}

type SchemaRequest struct{}

type SchemaResponse struct {// Schema is the schema of the data source.Schemaschema.Schema// Diagnostics report errors or warnings related to validating the data// source configuration. An empty slice indicates success, with no warnings// or errors generated.Diagnosticsdiag.Diagnostics}

type StateMover struct {// SourceSchema is an optional schema for the intended source resource state// and schema version. While not required, setting this will populate// [MoveStateRequest.SourceState] when possible similar to other [Resource]// types.//// State conversion errors based on this schema are only logged at DEBUG// level as there may be multiple [StateMover] implementations on the same// target resource for differing source resources. The [StateMover]// implementation will still be called even with these errors, so it is// important that implementations verify the request via the// [MoveStateRequest.SourceTypeName] and other fields before attempting// to use [MoveStateRequest.SourceState].//// If not set, source state data is only available in// [MoveStateRequest.SourceRawState].SourceSchema *schema.Schema// StateMove defines the logic for determining whether the request source// resource information should match this implementation, and if so, the// data transformation of the source resource state to the current schema// version state of this [Resource].//// The [context.Context] parameter contains framework-defined loggers and// supports request cancellation.//// The [MoveStateRequest] parameter contains source resource information.// If [SourceSchema] was set, the [MoveStateRequest.SourceState] field will// be available. Otherwise, the [MoveStateRequest.SourceRawState] must be// used.//// The [MoveStateResponse] parameter can either remain unmodified to signal// to the framework that this implementation should be considered skipped or// must contain the transformed state data to signal a successful move. Any// returned error diagnostics will cause the framework to immediately// respond with those errors and without calling other [StateMover]// implementations.StateMover func(context.Context,MoveStateRequest, *MoveStateResponse)}

type StateUpgrader struct {// Schema information for the prior state version. While not required,// setting this will populate the UpgradeStateRequest type State// field similar to other Resource data types. This allows for easier data// handling such as calling Get() or GetAttribute().//// If not set, prior state data is available in the// UpgradeResourceStateRequest type RawState field.PriorSchema *schema.Schema// Provider defined logic for upgrading a resource state from the prior// state version to the current schema version.//// The context.Context parameter contains framework-defined loggers and// supports request cancellation.//// The UpgradeStateRequest parameter contains the prior state data.// If PriorSchema was set, the State field will be available. Otherwise,// the RawState must be used.//// The UpgradeStateResponse parameter should contain the upgraded// state data and can be used to signal any logic warnings or errors.StateUpgrader func(context.Context,UpgradeStateRequest, *UpgradeStateResponse)}

type UpdateRequest struct {// Config is the configuration the user supplied for the resource.//// This configuration may contain unknown values if a user uses// interpolation or other functionality that would prevent Terraform// from knowing the value at request time.Configtfsdk.Config// Plan is the planned state for the resource.Plantfsdk.Plan// State is the current state of the resource prior to the Update// operation.Statetfsdk.State// Identity is the planned identity for the resource. If the resource does not// support identity, this value will not be set.Identity *tfsdk.ResourceIdentity// ProviderMeta is metadata from the provider_meta block of the module.ProviderMetatfsdk.Config// Private is provider-defined resource private state data which was previously// stored with the resource state. Any existing data is copied to// UpdateResponse.Private to prevent accidental private state data loss.//// Use the GetKey method to read data. Use the SetKey method on// UpdateResponse.Private to update or remove a value.Private *privatestate.ProviderData}

type UpdateResponse struct {// State is the state of the resource following the Update operation.// This field is pre-populated from UpdateResourceRequest.Plan and// should be set during the resource's Update operation.Statetfsdk.State// Identity is the identity of the resource following the Update operation.// This field is pre-populated from UpdateRequest.Identity and// should be set during the resource's Update operation.//// If the resource does not support identity, this value will not be set and will// raise a diagnostic if set by the resource's Update operation.Identity *tfsdk.ResourceIdentity// Private is the private state resource data following the Update operation.// This field is pre-populated from UpdateRequest.Private and// can be modified during the resource's Update operation.Private *privatestate.ProviderData// Diagnostics report errors or warnings related to updating the// resource. An empty slice indicates a successful operation with no// warnings or errors generated.Diagnosticsdiag.Diagnostics}

type UpgradeIdentityRequest struct {// Previous state of the resource identity in JSON format// (Terraform CLI 0.12 and later) This data is always available,// regardless of whether the wrapping IdentityUpgrader type// PriorSchema field was present.//// This is advanced functionality for providers wanting to skip the full// redeclaration of older identity schemas and instead use lower level handlers// to transform data. A typical implementation for working with this data will// call the Unmarshal() method.RawIdentity *tfprotov6.RawState// Previous identity of the resource if the wrapping IdentityUpgrader// type PriorSchema field was present. When available, this allows for// easier data handling such as calling Get() or GetAttribute().Identity *tfsdk.ResourceIdentity}

type UpgradeIdentityResponse struct {// Upgraded identity of the resource, which should match the current identity//schema version.//// This field allows for easier data handling such as calling Set() or// SetAttribute().//// All data must be populated to prevent data loss during the upgrade// operation. No prior identity data is copied automatically.Identity *tfsdk.ResourceIdentity// Diagnostics report errors or warnings related to upgrading the resource// identity state. An empty slice indicates success, with no warnings// or errors generated.Diagnosticsdiag.Diagnostics}

type UpgradeStateRequest struct {// Previous state of the resource in JSON (Terraform CLI 0.12 and later)// or flatmap format, depending on which version of Terraform CLI last// wrote the resource state. This data is always available, regardless// whether the wrapping StateUpgrader type PriorSchema field was// present.//// This is advanced functionality for providers wanting to skip the full// redeclaration of older schemas and instead use lower level handlers to// transform data. A typical implementation for working with this data will// call the Unmarshal() method.//// TODO: Create framework defined type that is not protocol specific.// Reference:https://github.com/hashicorp/terraform-plugin-framework/issues/340RawState *tfprotov6.RawState// Previous state of the resource if the wrapping StateUpgrader// type PriorSchema field was present. When available, this allows for// easier data handling such as calling Get() or GetAttribute().State *tfsdk.State}

type UpgradeStateResponse struct {// Diagnostics report errors or warnings related to upgrading the resource// state. An empty slice indicates a successful operation with no warnings// or errors generated.Diagnosticsdiag.Diagnostics// Upgraded state of the resource, which should match the current schema// version. If set, this will override State.//// This field is intended only for advanced provider functionality, such as// skipping the full redeclaration of older schemas or using lower level// handlers to transform data. Call tfprotov6.NewDynamicValue() to set this// value.//// All data must be populated to prevent data loss during the upgrade// operation. No prior state data is copied automatically.//// TODO: Remove in preference of requiring State, rather than using either// a new framework defined type or keeping this protocol specific type.// Reference:https://github.com/hashicorp/terraform-plugin-framework/issues/340DynamicValue *tfprotov6.DynamicValue// Upgraded state of the resource, which should match the current schema// version. If DynamicValue is set, it will override this value.//// This field allows for easier data handling such as calling Set() or// SetAttribute(). It is generally recommended over working with the lower// level types and functionality required for DynamicValue.//// All data must be populated to prevent data loss during the upgrade// operation. No prior state data is copied automatically.Statetfsdk.State}

type ValidateConfigClientCapabilities struct {// WriteOnlyAttributesAllowed indicates that the Terraform client// initiating the request supports write-only attributes for managed// resources.WriteOnlyAttributesAllowedbool}

type ValidateConfigRequest struct {// Config is the configuration the user supplied for the resource.//// This configuration may contain unknown values if a user uses// interpolation or other functionality that would prevent Terraform// from knowing the value at request time.Configtfsdk.Config// ClientCapabilities defines optionally supported protocol features for// the ValidateResourceConfig RPC, such as forward-compatible Terraform// behavior changes.ClientCapabilitiesValidateConfigClientCapabilities}

type ValidateConfigResponse struct {// Diagnostics report errors or warnings related to validating the resource// configuration. An empty slice indicates success, with no warnings or// errors generated.Diagnosticsdiag.Diagnostics}