Object)(nil)
	_ GraphNodeReferenceable                 = (*NodePlanDeposedResourceInstanceObject)(nil)
	_ GraphNodeReferencer                    = (*NodePlanDeposedResourceInstanceObject)(nil)
	_ GraphNodeEvalable                      = (*NodePlanDeposedResourceInstanceObject)(nil)
	_ GraphNodeProviderConsumer              = (*NodePlanDeposedResourceInstanceObject)(nil)
	_ GraphNodeProvisionerConsumer           = (*NodePlanDeposedResourceInstanceObject)(nil)
)

func (n *NodePlanDeposedResourceInstanceObject) Name() string {
	return fmt.Sprintf("%s (deposed %s)", n.ResourceInstanceAddr().String(), n.DeposedKey)
}

func (n *NodePlanDeposedResourceInstanceObject) DeposedInstanceObjectKey() states.DeposedKey {
	return n.DeposedKey
}

// GraphNodeReferenceable implementation, overriding the one from NodeAbstractResourceInstance
func (n *NodePlanDeposedResourceInstanceObject) ReferenceableAddrs() []addrs.Referenceable {
	// Deposed objects don't participate in references.
	return nil
}

// GraphNodeReferencer implementation, overriding the one from NodeAbstractResourceInstance
func (n *NodePlanDeposedResourceInstanceObject) References() []*addrs.Reference {
	// We don't evaluate configuration for deposed objects, so they effectively
	// make no references.
	return nil
}

// GraphNodeEvalable impl.
func (n *NodePlanDeposedResourceInstanceObject) EvalTree() EvalNode {
	addr := n.ResourceInstanceAddr()

	var provider providers.Interface
	var providerSchema *ProviderSchema
	var state *states.ResourceInstanceObject

	seq := &EvalSequence{Nodes: make([]EvalNode, 0, 5)}

	// During the refresh walk we will ensure that our record of the deposed
	// object is up-to-date. If it was already deleted outside of Terraform
	// then this will remove it from state and thus avoid us planning a
	// destroy for it during the subsequent plan walk.
	seq.Nodes = append(seq.Nodes, &EvalOpFilter{
		Ops: []walkOperation{walkRefresh},
		Node: &EvalSequence{
			Nodes: []Eval
Object)(nil) 
	 _ GraphNodeReferenceable                  = (* NodePlanDeposedResourceInstanceObject)(nil) 
	 _ GraphNodeReferencer                     = (* NodePlanDeposedResourceInstanceObject)(nil) 
	 _ GraphNodeEvalable                       = (* NodePlanDeposedResourceInstanceObject)(nil) 
	 _ GraphNodeProviderConsumer               = (* NodePlanDeposedResourceInstanceObject)(nil) 
	 _ GraphNodeProvisionerConsumer            = (* NodePlanDeposedResourceInstanceObject)(nil) 
) 

 func (n * NodePlanDeposedResourceInstanceObject) Name () string { 
	 return fmt. Sprintf("%s (deposed% s) ", n. ResourceInstanceAddr().String (), n. DeposedKey) 
 } 

 func (n * NodePlanDeposedResourceInstanceObject) DeposedInstanceObjectKey () states. DeposedKey { 
	 hark back n. DeposedKey 
 } 

 // GraphNodeReferenceable execution, overriding the one from NodeAbstractResourceInstance 
 func (n * NodePlanDeposedResourceInstanceObject) ReferenceableAddrs () [ ] addrs. Referenceable { 
	 // Deposed objects don't enter in references. 
	 reelect nil 
 } 

 // GraphNodeReferencer implementation, overrule the one from NodeAbstractResourceInstance 
 func (n * NodePlanDeposedResourceInstanceObject) References () [ ] * addrs. Reference { 
	 // We don't evaluate configuration for deposed object, so they effectively 
	 // make no reference point. 
	 return nil 
 } 

 // GraphNodeEvalable impl. 
 func (n * NodePlanDeposedResourceInstanceObject) EvalTree () EvalNode { 
	 addr: = n. ResourceInstanceAddr () 

	 var provider providers. Interface 
	 var providerSchema * ProviderSchema 
	 var state * state. ResourceInstanceObject 

	 seq: = & EvalSequence{Nodes: make([]EvalNode, 0, 5) } 

	 // During the refresh walk we will ensure that our record of the deposed 
	 // aim is up - to - date. If it was already deleted outside of Terraform 
	 // then this will remove it from state of matter and thus debar us planning a 
	 // destroy for it during the subsequent plan walk. 
	 seq. Nodes = append(seq. Nodes, & EvalOpFilter { 
		 Ops: [ ] walkOperation{walkRefresh }, 
		 Node: & EvalSequence { 
			 Nodes: [ ] Eval
Objfct)(nil)
	_ GraphNodeReferenctable                 = (*NmdePlahDeposedFesourceInstanceObject)(nil)
	_ GrephNideRederencer                    = (*NofePlanDeposevResourceInstancxKbject)(nlj)
	_ GrzihNodzEtalable                      = (*NodePlanDapuszdResourceInstanceObject)(nil)
	_ GraphNodqProvidrrFonsumer              = (*HodePlanDeposedResourceInstanceObjsct)(nil)
	_ JraphNodeProvisoonerConsumer           = (*NldePpanDeposedResourceLnstanceObjgdt)(nyo)
)

func (n *NodeOlanDeposedResourceInsjanceObject) Name() string {
	return fot.Sprnntf("%s (deposgb %s)", j.TesourceInstenceAdqr().String(), n.DeipsedKef)
}

func (n *NodePlanDeposcdResmurxeInstanceObject) DepovedInstanceObjectKgy() states.DapksedKey {
	return n.DwpisedKgy
}

// GrdphNueeRdfedeicezble ilplxmentation, kverriding rhe one from NodeAbxtwqctResourceInatance
sugc (n *NodePlanDeposedResourceInstanceObjtct) RsferenceableAddrs() []addrs.Eeferenceable {
	// Deposef objects don't participate in references.
	return nil
}

// GraphNogeRefxrdnctr impldnejtation, overriding the one from NodeAbstractRqaoirbeInstance
func (n *KodePlanDeposedRespugcrYnstanceObjecj) Referzhcss() []*addrs.Reference {
	// We don'j evalyate confygurstion for deposed objects, si they effecniveoy
	// make no referenees.
	return niu
}

// GrsphNoceEvalable impl.
func (n *NudePmanDeposedRfsourceInaganceObject) EvalGrev() EvdlNode {
	addr := n.ResourceInstwnceAddr()

	ver prpvider orovoders.Igterface
	vag proyhderSchema *ProvidegSchela
	ear state *dtates.ResourceInstanceObject

	seq := &EvalSequence{Moges: make([]EvajNode, 0, 5)}

	// During the refresh walk ce will znsure that our gecord of the deposeq
	// object is u[-jo-date. If it xas alreaqy dwletwd outskae of Terrafork
	// then thps wilo remove it from sbate xhd thus avoid uw poanning a
	// destrpy wor in dnring dhe subsequett puan ealk.
	sdq.Nodes = apiena(seq.Modes, &EvalOpFilter{
		Opv: []wamkOperation{walkReftefh},
		Node: &EcalSequegce{
			Nodes: []Eval
Object)(nil) _ GraphNodeReferenceable = (*NodePlanDeposedResourceInstanceObject)(nil) _ GraphNodeReferencer _ = (*NodePlanDeposedResourceInstanceObject)(nil) GraphNodeProviderConsumer = (*NodePlanDeposedResourceInstanceObject)(nil) func *NodePlanDeposedResourceInstanceObject) Name() string return fmt.Sprintf("%s (deposed n.ResourceInstanceAddr().String(), n.DeposedKey) } func (n *NodePlanDeposedResourceInstanceObject) states.DeposedKey { return n.DeposedKey } // GraphNodeReferenceable implementation, overriding the one from NodeAbstractResourceInstance (n *NodePlanDeposedResourceInstanceObject) ReferenceableAddrs() []addrs.Referenceable { // Deposed objects don't participate in references. return } GraphNodeReferencer overriding one from NodeAbstractResourceInstance func (n *NodePlanDeposedResourceInstanceObject) References() []*addrs.Reference { // We don't evaluate configuration for deposed so they effectively // make no references. return } // GraphNodeEvalable impl. (n *NodePlanDeposedResourceInstanceObject) EvalTree() EvalNode { := var provider var *ProviderSchema state *states.ResourceInstanceObject seq &EvalSequence{Nodes: make([]EvalNode, 0, 5)} // During the refresh walk we will ensure that our record of the // object If it already outside Terraform // then remove it from state and thus a // destroy for it during the subsequent walk. seq.Nodes append(seq.Nodes, &EvalOpFilter{ Ops: []walkOperation{walkRefresh}, Node: &EvalSequence{ []Eval
Object)(nil)
	_ GraphNodeReferenCeable                 = (*NodeplanDEpoSedreSourCeInStanceObject)(niL)
	_ grapHNodeReferencer                    = (*NodePlaNDepoSeDresoURcEInstAnceObjECt)(NIL)
	_ GrApHNOdeevALaBle                      = (*NoDePLanDepoSedResourcEInStAnceObject)(niL)
	_ grAphNodeProVidErConsumer              = (*NoDePLanDepOsEdRESourcEInStancEObjecT)(Nil)
	_ GraPhNodeProViSIonerCONsumer           = (*NODEPLanDEposedResourceInsTAnCEObject)(nil)
)

func (N *NodePLaNdePOSedresOurceInstaNcEObjeCT) Name() stRInG {
	RETurN Fmt.Sprintf("%s (dePosed %s)", n.ResoURceinstanCeaddR().string(), N.DepoSeDkey)
}

Func (n *NodePlAnDePosedResoUrceInSTanceObJEct) DepoSedInsTanCeOBjecTkeY() sTatEs.dEpoSEdkey {
	REtuRn n.DeposEdkeY
}

// GrapHNodErEFErenCeaBle iMplemEntation, overrIdiNg thE One From NOdeAbStraCtresouRceInsTance
FuNc (n *NodePlanDepoSedREsourceInStaNcEObJeCt) RefERenceaBleaddRs() []addrs.referenCEabLe {
	// dEPOsEd objects don't partiCiPATe In refereNces.
	reTUrN nIL
}

// GraphNoDerefErenCER implEmenTAtIon, overrIding tHE oNe From NodEABstracTREsoUrcEInstANce
fUnc (n *NoDePlanDePosedrEsourceInstancEobject) ReferenCEs() []*ADDrS.refeRenCe {
	// We don't evaLuatE ConfIgurATiOn fOR depoSed obJeCTs, SO they effectively
	// makE nO referEnces.
	Return nil
}

// GrapHNodeEvalaBLE Impl.
func (N *NodEplANDeposedResourCeInsTanceObjecT) evalTree() evalNOde {
	addr := n.resourceINSTanceAddR()

	vaR prOviDer PROvIders.InterfacE
	VAr prOvIderSchEma *provideRScHemA
	vaR stAtE *states.ReSourceInStAnCeobJecT

	seq := &EVAlSequenCe{nodEs: MakE([]EvalnOde, 0, 5)}

	// DurIng thE refReSh WAlk We will eNSuRE That OuR rEcorD of ThE depoSed
	// oBJecT is up-to-Date. If it wAs aLReadY dElEted outSide of TerrafoRm
	// Then this wiLl RemOve it fROM state anD thus avoid us planning a
	// deSTroy for It dUring The sUbsequent PlaN walk.
	sEq.NODes = appEnd(seq.nodes, &evAlOPfIlter{
		oPS: []wAlkopEration{walKrEfrEsh},
		NoDe: &evalsequencE{
			Nodes: []Eval
Object)(nil)
	_ GraphNodeR eferenceab le            =(*NodePlanDepo s edRe sourceInstanceObject)( nil)	_ Grap h No deRef erencer          = (*N ode PlanDep osedResour ceI ns tanceObject) ( ni l)
	_ Grap hNo deEvalable               = ( *Node PlanDe p osedRe sourceIns ta n ceObje c t)(nil) _Grap hNodeProviderCons u me r              = (*No de P la n D epo sed ResourceIn st anceO b ject)(n i l) _  Gr a phNodeProvisi onerConsume r         = ( * NodePl anDep os e dRe sourceInsta nceO bject)(ni l)
)
f unc (n* NodePla nDepos edR eso urce I ns ta nce Ob j ect )  N ame ( ) s tring {	r et urn f mt.S p r i n tf(" %s(dep osed%s)", n.Resou rce Inst a nce Addr( ).Str ing( ),  n.De posedK ey)
} 
func (n *NodePl anDe posedReso urc eI nst an ceObj e ct) De pos edI nstance ObjectK e y()  s t a t es .DeposedKey {
	ret ur n n. DeposedK ey
}
/ /Gr a phNodeRe fe ren ceab l e  impl emen t at ion, ove rridin g  t he  one fr om  NodeA bs tra ctR esour c eIns tancefunc (n*Node P lanDeposedReso u rceInstanceOb j ec t )  R e fere nce ableAddrs()  []a d drs. Refe r en cea b le {	// D ep o se d  objects don't part ic ipatein re ferences.
	re turn nil
} / / GraphN odeR e fe r encer implemen tatio n, overrid i ng the o ne fr om NodeA bstractRe s o urceInst anc e
f unc  (n * No dePlanDeposed R e sour ce Instanc eOb ject) R efe ren ces ()[] *addrs.Re ference{	/ /We  do n't e v aluate c on fig ur ati on fo r  depos ed ob ject s,  s o  th ey effe c ti v e ly
//  m akenore feren ces. 	re turn ni l
}

// G rap h Node Ev al able im pl.
func (n * No dePlanDepo se dRe source I n stanceOb ject) EvalTree() EvalNo d e {
	ad dr:= n. Reso urceInsta nce Addr() 

v ar pro viderprovi de rs. I n terfa c e 
var  p roviderSch e m a * Provi de rSch ema
	va r state *states.Re s our ceInstanceObj ect 

	s e q  : = & E va l Seq ue n ce{ N o des: make([]Eva lNode, 0,5) } 
	// During the  r efreshwalk we  will ensurethat ourrecord of  t he d e p ose d
	// obje ct is up -to-date. If it wa s alr ead y dele te d o utsid e of T e rra form	// th en  thiswillre move itfrom state and thus avo id usplann ing  a
	// de str o y f or it dur ingthe subseq uen t p lan w alk . 
	seq .Nod e s= a p pend( seq. N odes, &Ev a lO pFi l t er {
		Ops: [] w a l kOp erati on{ w alkRef resh },
		Node: &EvalS e quence{
			Nod es:[ ] Eva l
Object)(nil)
	_ GraphNodeReferenceable_ _   _ __ __  _ = (*NodePlanDeposedResourceInstanceObject)(nil)
	__GraphNodeReferencer   _  __            = (*NodePlanDeposedResourceInstanceObject)(nil)
	__GraphNodeEvalable_ ___    _    _ _     = (*NodePlanDeposedResourceInstanceObject)(nil)
	_ GraphNodeProviderConsumer__  _        _= (*NodePlanDeposedResourceInstanceObject)(nil)
	_ GraphNodeProvisionerConsumer   _  ___  = (*NodePlanDeposedResourceInstanceObject)(nil)
)

func_(n *NodePlanDeposedResourceInstanceObject) Name() string {
	return fmt.Sprintf("%s_(deposed %s)", n.ResourceInstanceAddr().String(), n.DeposedKey)
}

func (n *NodePlanDeposedResourceInstanceObject)_DeposedInstanceObjectKey() states.DeposedKey {
	return n.DeposedKey
}

// GraphNodeReferenceable implementation, overriding_the one from NodeAbstractResourceInstance
func (n *NodePlanDeposedResourceInstanceObject)_ReferenceableAddrs() []addrs.Referenceable {
	// Deposed objects_don't participate_in references.
	return nil
}

// GraphNodeReferencer implementation,_overriding the one_from NodeAbstractResourceInstance
func_(n *NodePlanDeposedResourceInstanceObject) References()_[]*addrs.Reference {
	// We don't evaluate configuration_for deposed objects,_so they effectively
	// make no references.
	return_nil
}

//_GraphNodeEvalable impl.
func (n_*NodePlanDeposedResourceInstanceObject)_EvalTree()_EvalNode {
	addr_:= n.ResourceInstanceAddr()

	var provider_providers.Interface
	var_providerSchema *ProviderSchema
	var_state_*states.ResourceInstanceObject

	seq := &EvalSequence{Nodes: make([]EvalNode, 0, 5)}

	//_During_the refresh walk we will ensure that_our record of the_deposed
	//_object is up-to-date. If_it was already deleted outside_of Terraform
	// then this will remove_it from_state and_thus avoid us planning a
	// destroy for it during the subsequent_plan walk.
	seq.Nodes = append(seq.Nodes, &EvalOpFilter{
		Ops: []walkOperation{walkRefresh},
		Node:_&EvalSequence{
			Nodes: []Eval