container

type BlueprintContainer interface {
	// StageChanges deals with staging changes to be deployed, comparing the effect of applying
	// the loaded blueprint to the existing instance stored in state for the instance ID it was
	// loaded with.
	// This will stream changes to the provided channels for each resource, child blueprint and link
	// that will be affected by the changes, a final message will be sent to the complete channel
	// containing the full set of changes that will be made to the blueprint instance when deploying
	// the changes.
	// Parameter overrides can be provided to add extra instance-specific variables
	// that were not defined when the container was loaded or to provide all variables
	// when the container was loaded with an empty set.
	StageChanges(
		ctx context.Context,
		input *StageChangesInput,
		channels *ChangeStagingChannels,
		paramOverrides core.BlueprintParams,
	) error
	// Deploy deals with deploying the blueprint for the given instance ID.
	// When an instance ID is omitted, the container will treat the deployment
	// as a new instance of the blueprint where the provided change set only includes
	// new resources, children and links.
	// Deploying a blueprint involves creating, updating and destroying resources
	// based on the staged changes.
	// This will stream updates to the provided channels for each resource, child blueprint and link
	// that has either been updated, created or removed.
	// Deploy should also be used as the mechanism to rollback a blueprint to a previous
	// revision managed in version control or a data store for blueprint source documents.
	//
	// There is synchronous and asynchronous error handling, synchronous errors will be returned
	// during the initial setup phase of the deployment process.
	// Most errors should be handled by the container and sent to the appropriate channel
	// as a deployment update message.
	Deploy(
		ctx context.Context,
		input *DeployInput,
		channels *DeployChannels,
		paramOverrides core.BlueprintParams,
	) error
	// Destroy deals with destroying all the resources, child blueprints and links
	// for a blueprint instance.
	// Like Deploy, Destroy requires changes to be staged and passed in to ensure that
	// the user gets a chance to review everything that will be destroyed before
	// starting the process; this should go hand and hand with a confirmation step and prompts
	// to allow the user to dig deeper in the tools built on top of the framework.
	// This will stream updates to the provided channels for each resource, child blueprint and link
	// that has been removed.
	//
	// There is no synchronous error handling, all errors will be sent to the provided error
	// channel. Most errors should be handled by the container and sent to the appropriate channel
	// as an update message.
	Destroy(
		ctx context.Context,
		input *DestroyInput,
		channels *DeployChannels,
		paramOverrides core.BlueprintParams,
	)
	// SpecLinkInfo provides the chain link and warnings for potential issues
	// with links provided in the given specification.
	SpecLinkInfo() links.SpecLinkInfo
	// BlueprintSpec returns the specification for the loaded blueprint
	// including the parsed schema and a convenience method to get resource
	// schemas by name.
	BlueprintSpec() speccore.BlueprintSpec
	// RefChainCollector returns the reference chain collector used to collect
	// reference chains for resources and child blueprints.
	// This is useful for allowing parent contexts to get access to the collected
	// references for a blueprint.
	// For example, extracting the references from an expanded version of a blueprint
	// that contains resource templates.
	RefChainCollector() refgraph.RefChainCollector
	// ResourceTemplates holds a mapping of resource names to the name of the resource
	// template it was derived from.
	// This allows retention of information about the original resource template
	// that a resource was derived from in a source blueprint document.
	ResourceTemplates() map[string]string
	// Diagnostics returns warning and informational diagnostics for the loaded blueprint
	// that point out potential issues that may occur when executing
	// a blueprint.
	// These diagnostics can contain errors, however, the error returned on failure to load a blueprint
	// should also be unpacked to get the precise location and information about the reason loading the
	// blueprint failed.
	Diagnostics() []*core.Diagnostic
}

type BlueprintContainerDependencies struct {
	StateContainer            state.Container
	Providers                 map[string]provider.Provider
	ResourceRegistry          resourcehelpers.Registry
	LinkRegistry              provider.LinkRegistry
	LinkInfo                  links.SpecLinkInfo
	ResourceTemplates         map[string]string
	RefChainCollector         refgraph.RefChainCollector
	SubstitutionResolver      subengine.SubstitutionResolver
	ChangeStager              ResourceChangeStager
	Clock                     core.Clock
	IDGenerator               core.IDGenerator
	DeploymentStateFactory    DeploymentStateFactory
	ChangeStagingStateFactory ChangeStagingStateFactory
	BlueprintPreparer         BlueprintPreparer
	LinkChangeStager          LinkChangeStager
	ChildChangeStager         ChildChangeStager
	ResourceDestroyer         ResourceDestroyer
	ChildBlueprintDestroyer   ChildBlueprintDestroyer
	LinkDestroyer             LinkDestroyer
	LinkDeployer              LinkDeployer
	DriftChecker              drift.Checker
	ResourceDeployer          ResourceDeployer
	ChildBlueprintDeployer    ChildBlueprintDeployer
	DefaultRetryPolicy        *provider.RetryPolicy
	Logger                    core.Logger
}

type BlueprintDestroyer interface {
	Destroy(
		ctx context.Context,
		input *DestroyInput,
		channels *DeployChannels,
		paramOverrides core.BlueprintParams,
	)
}

type BlueprintPrepareResult struct {
	ResourceProviderMap map[string]provider.Provider
	BlueprintContainer  BlueprintContainer
	ParallelGroups      [][]*DeploymentNode
}

type BlueprintPreparer interface {
	Prepare(
		ctx context.Context,
		blueprint *schema.Blueprint,
		resolveFor subengine.ResolveForStage,
		changes *changes.BlueprintChanges,
		linkInfo links.SpecLinkInfo,
		paramOverrides core.BlueprintParams,
	) (*BlueprintPrepareResult, error)
}

type ChangeStagingChannels struct {
	// ResourceChangesChan receives change sets for each resource in the blueprint.
	ResourceChangesChan chan ResourceChangesMessage
	// ChildChangesChan receives change sets for child blueprints once all
	// changes for the child blueprint have been staged.
	ChildChangesChan chan ChildChangesMessage
	// LinkChangesChan receives change sets for links between resources.
	LinkChangesChan chan LinkChangesMessage
	// CompleteChan is used to signal that all changes have been staged
	// containing the full set of changes that will be made to the blueprint instance
	// when deploying the changes.
	CompleteChan chan changes.BlueprintChanges
	// ErrChan is used to signal that an error occurred while staging changes.
	ErrChan chan error
}

type ChangeStagingState interface {
	// AddElementsThatMustBeRecreated adds elements that must be
	// recreated due to removal of dependencies.
	// This adds the elements to the existing set of elements that must be recreated
	// and does not replace the existing set.
	AddElementsThatMustBeRecreated(mustRecreate *CollectedElements)
	// ApplyResourceChanges applies the changes for a given resource to the staging state.
	ApplyResourceChanges(changes ResourceChangesMessage)
	// UpdateLinkStagingState updates the staging state for links containing
	// the resource represented by the provided ChainLinkNode.
	UpdateLinkStagingState(node *links.ChainLinkNode) []*LinkPendingCompletion
	// MustRecreateResourceOnRemovedDependencies returns true if the resource
	// represented by the provided resource name must be recreated
	// due to the removal of dependencies.
	MustRecreateResourceOnRemovedDependencies(resourceName string) bool
	// CountPendingLinksForGroup returns the number of pending links for the
	// provided group of nodes for the current change staging operation.
	CountPendingLinksForGroup(group []*DeploymentNode) int
	// ApplyLinkChanges applies the changes for a given link to the staging state.
	ApplyLinkChanges(changes LinkChangesMessage)
	// ApplyChildChanges applies the changes for a given child blueprint
	// to the staging state.
	ApplyChildChanges(changes ChildChangesMessage)
	// GetResourceChanges returns the changes for the provided resource name
	// from the staging state.
	// If no changes are found for the provided resource name, nil is returned.
	GetResourceChanges(resourceName string) *provider.Changes
	// MarkLinkAsNoLongerPending marks the link between the provided resource nodes
	// as no longer pending in the staging state.
	MarkLinkAsNoLongerPending(resourceANode, resourceBNode *links.ChainLinkNode)
	// UpdateExportChanges updates the export changes in the staging state.
	UpdateExportChanges(collectedExportChanges *changes.IntermediaryBlueprintChanges)
	// UpdateMetadataChanges updates the blueprint-wide metadata changes in the staging state.
	UpdateMetadataChanges(
		changes *changes.MetadataChanges,
		resolveOnDeploy []string,
	)
	// ExtractBlueprintChanges extracts the changes that have been staged
	// for the deployment to be sent to the client initiating the change staging operation.
	ExtractBlueprintChanges() changes.BlueprintChanges
}

type ChangeStagingStateFactory func() ChangeStagingState

type ChildBlueprintDeployer interface {
	Deploy(
		ctx context.Context,
		parentInstanceID string,
		parentInstanceTreePath string,
		includeTreePath string,
		childNode *refgraph.ReferenceChainNode,
		changes *changes.BlueprintChanges,
		deployCtx *DeployContext,
	)
}

type ChildBlueprintDestroyer interface {
	Destroy(
		ctx context.Context,
		childBlueprintElement state.Element,
		parentInstanceID string,
		parentInstanceTreePath string,
		includeTreePath string,
		blueprintDestroyer BlueprintDestroyer,
		deployCtx *DeployContext,
	)
}

type ChildBlueprintIDInfo struct {
	ChildInstanceID string
	ChildName       string
}

type ChildBlueprintLoaderFactory func(
	derivedFromTemplate []string,
	resourceTemplates map[string]string,
) Loader

type ChildChangeStager interface {
	StageChanges(
		ctx context.Context,
		childInstanceInfo *ChildInstanceInfo,
		node *refgraph.ReferenceChainNode,
		paramOverrides core.BlueprintParams,
		channels *ChangeStagingChannels,
		logger core.Logger,
	)
}

type ChildChangesMessage struct {
	ChildBlueprintName string                   `json:"childBlueprintName"`
	Removed            bool                     `json:"removed"`
	New                bool                     `json:"new"`
	Changes            changes.BlueprintChanges `json:"changes"`
}

type ChildDeployUpdateMessage struct {
	// ParentInstanceID is the ID of the parent blueprint instance
	// the message is associated with.
	ParentInstanceID string `json:"parentInstanceId"`
	// ChildInstanceID is the ID of the child blueprint instance
	// the message is associated with.
	ChildInstanceID string `json:"childInstanceId"`
	// ChildName is the logical name of the child blueprint
	// as defined in the source blueprint as an include.
	ChildName string `json:"childName"`
	// Group is the group number the child blueprint belongs to relative to the ordering
	// for components in the current blueprint associated with the parent instance ID.
	Group int `json:"group"`
	// Status holds the status of the child blueprint.
	Status core.InstanceStatus `json:"status"`
	// FailureReasons holds a list of reasons why the child blueprint failed to deploy
	// if the status update is for a failure.
	FailureReasons []string `json:"failureReasons,omitempty"`
	// UpdateTimestamp is the unix timestamp in seconds for
	// when the status update occurred.
	UpdateTimestamp int64 `json:"updateTimestamp"`
	// Durations holds duration information for a child blueprint deployment.
	// Duration information is attached on one of the following status updates:
	// - InstanceStatusDeployed
	// - InstanceStatusDeployFailed
	// - InstanceStatusDestroyed
	// - InstanceStatusUpdated
	// - InstanceStatusUpdateFailed
	Durations *state.InstanceCompletionDuration `json:"durations,omitempty"`
}

type ChildInstanceInfo struct {
	ParentInstanceID       string
	ParentInstanceTreePath string
	IncludeTreePath        string
}

type CollectedElements struct {
	Resources []*ResourceIDInfo
	Children  []*ChildBlueprintIDInfo
	Links     []*LinkIDInfo
	Total     int
}

type CollectedResourceData struct {
	Spec         *core.MappingNode
	Metadata     *state.ResourceMetadataState
	TemplateName string
	Description  string
}

type DependenciesOverrider func(
	depsToOverride *BlueprintContainerDependencies,
) *BlueprintContainerDependencies

type DeployChannels struct {
	// ResourceUpdateChan receives messages about the status of deployment for resources.
	ResourceUpdateChan chan ResourceDeployUpdateMessage
	// LinkUpdateChan receives messages about the status of deployment for links.
	LinkUpdateChan chan LinkDeployUpdateMessage
	// ChildUpdateChan receives messages about the status of deployment for child blueprints.
	ChildUpdateChan chan ChildDeployUpdateMessage
	// DeploymentUpdateChan receives messages about the status of the blueprint instance deployment.
	DeploymentUpdateChan chan DeploymentUpdateMessage
	// FinishChan is used to signal that the blueprint instance deployment has finished,
	// the message will contain the final status of the deployment.
	FinishChan chan DeploymentFinishedMessage
	// ErrChan is used to signal that an unexpected error occurred during deployment of changes.
	ErrChan chan error
}

type DeployContext struct {
	StartTime  time.Time
	Rollback   bool
	Destroying bool
	State      DeploymentState
	Channels   *DeployChannels
	// A snapshot of the instance state taken before deployment.
	InstanceStateSnapshot *state.InstanceState
	ParamOverrides        core.BlueprintParams
	ResourceProviders     map[string]provider.Provider
	CurrentGroupIndex     int
	DeploymentGroups      [][]*DeploymentNode
	InputChanges          *changes.BlueprintChanges
	// A mapping of resource names to the name of the resource
	// templates they were derived from.
	ResourceTemplates map[string]string
	// Holds the container for the blueprint after preparation/pre-processing
	// including template expansion and applying resource conditions.
	PreparedContainer BlueprintContainer
	// Provides a deployment-scoped registry for resources that will be packed
	// with the parameter overrides supplied in a container "Deploy" or "Destroy"
	// method call.
	ResourceRegistry resourcehelpers.Registry
	Logger           core.Logger
}

type DeployEvent struct {
	// ResourceUpdateEvent is an event that is emitted when a resource is updated.
	ResourceUpdateEvent *ResourceDeployUpdateMessage
	// LinkUpdateEvent is an event that is emitted when a link is updated.
	LinkUpdateEvent *LinkDeployUpdateMessage
	// ChildUpdateEvent is an event that is emitted when a child blueprint is updated.
	ChildUpdateEvent *ChildDeployUpdateMessage
	// DeploymentUpdateEvent is an event that is emitted when the
	// deployment status of the blueprint instance is updated.
	DeploymentUpdateEvent *DeploymentUpdateMessage
	// FinishEvent is an event that is emitted when the deployment
	// of the blueprint instance has finished.
	FinishEvent *DeploymentFinishedMessage
}

type DeployInput struct {
	// InstanceID is the ID of the blueprint instance that the changes will be deployed for.
	// If this is set, `InstanceName` must be empty.
	InstanceID string
	// InstanceName is the user-defined name of the blueprint instance that
	// the changes will be deployed for.
	// If this is set, `InstanceID` must be empty.
	InstanceName string
	// Changes contains the changes that will be made to the blueprint instance.
	Changes *changes.BlueprintChanges
	// Rollback is used to indicate that the changes being deployed represent a rollback.
	// This is useful for ensuring the correct statuses are applied when changes within a child
	// blueprint need to be rolled back due to a failure in the parent blueprint.
	// The loaded blueprint is expected to be the version of the blueprint to roll back to
	// for a given blueprint instance.
	Rollback bool
}

type DeploymentFinishedMessage struct {
	// InstanceID is the ID of the blueprint instance
	// the message is associated with.
	InstanceID string `json:"instanceId"`
	// Status holds the status of the instance deployment.
	Status core.InstanceStatus `json:"status"`
	// FailureReasons holds a list of reasons why the instance failed to deploy
	// if the final status is a failure.
	FailureReasons []string `json:"failureReasons,omitempty"`
	// FinishTimestamp is the unix timestamp in seconds for
	// when the deployment finished.
	FinishTimestamp int64 `json:"finishTimestamp"`
	// UpdateTimestamp is the unix timestamp in seconds for
	// when the status update occurred.
	UpdateTimestamp int64 `json:"updateTimestamp"`
	// Durations holds duration information for the blueprint deployment.
	// Duration information is attached on one of the following status updates:
	// - InstanceStatusDeploying (preparation phase duration only)
	// - InstanceStatusDeployed
	// - InstanceStatusDeployFailed
	// - InstanceStatusDeployRollbackFailed
	// - InstanceStatusDeployRollbackComplete
	// - InstanceStatusDestroyed
	// - InstanceStatusDestroyFailed
	// - InstanceStatusDestroyRollbackFailed
	// - InstanceStatusDestroyRollbackComplete
	// - InstanceStatusUpdated
	// - InstanceStatusUpdateFailed
	// - InstanceStatusUpdateRollbackFailed
	// - InstanceStatusUpdateRollbackComplete
	Durations *state.InstanceCompletionDuration `json:"durations,omitempty"`
}

type DeploymentNode struct {
	ChainLinkNode *links.ChainLinkNode
	ChildNode     *refgraph.ReferenceChainNode
	// DirectDependencies holds the direct dependencies of the given deployment
	// node.
	// This isn't populated upon creation of the deployment node,
	// as ordering of the nodes does not compare every node,
	// the dependencies list would be incomplete.
	// This is primarily used for the deployment process where the container
	// will populate the direct dependencies of each node as a part of the
	// preparation phase.
	DirectDependencies []*DeploymentNode
}

type DeploymentNodeType string

type DeploymentState interface {
	// SetDestroyedElement marks an element in the current
	// deployment as destroyed.
	SetDestroyedElement(element state.Element)
	// SetUpdatedEleemnt marks an element in the current
	// deployment as updated.
	SetUpdatedElement(element state.Element)
	// SetCreatedElement marks an element in the current
	// deployment as created.
	SetCreatedElement(element state.Element)
	// SetElementInProgress marks an element in the current
	// deployment as in progress.
	SetElementInProgress(element state.Element)
	// IsElementInProgress checks if an element is currently in progress
	// in the deployment process.
	IsElementInProgress(element state.Element) bool
	// SetElementConfigComplete marks an element in the current
	// deployment as having its configuration completed.
	SetElementConfigComplete(element state.Element)
	// IsElementConfigComplete checks if an element has had its configuration
	// completed in the deployment process.
	IsElementConfigComplete(element state.Element) bool
	// CheckUpdateElementDeploymentStarted checks if the deployment of an element has already started
	// and updates the deployment state at the same time.
	// This makes checking and writing the deployment started state atomic while taking into account
	// other factors that should be considered when checking if the deployment should be started.
	// This is primarily useful for avoiding starting the deployment of an element
	// multiple times.
	CheckUpdateElementDeploymentStarted(element state.Element, otherConditionToStart bool) bool
	// SetLinkDurationInfo stores the duration information for multiple stages
	// of the deployment of a link.
	SetLinkDurationInfo(linkName string, durations *state.LinkCompletionDurations)
	// GetLinkDurationInfo returns the duration information for multiple stages
	// of the deployment of a link.
	GetLinkDurationInfo(linkName string) *state.LinkCompletionDurations
	// SetPrepareDuration sets the duration of the preparation phase for the deployment
	// of a blueprint instance.
	SetPrepareDuration(prepareDuration time.Duration)
	// SetResourceDurationInfo sets the duration information for the "config completion"
	// stage of the deployment of a resource.
	SetResourceDurationInfo(resourceName string, durations *state.ResourceCompletionDurations)
	// GetResourceDurationInfo returns the duration information for the "config completion"
	// stage of the deployment of a resource.
	GetResourceDurationInfo(resourceName string) *state.ResourceCompletionDurations
	// GetPrepareDuration returns the duration of the preparation phase for the deployment
	// of a blueprint instance.
	GetPrepareDuration() *time.Duration
	// SetResourceData sets the spec state and metadata for a resource that has been created
	// or updated.
	SetResourceData(resourceName string, specState *CollectedResourceData)
	// GetResourceData returns the spec state and metadata for a resource that has been created
	// or updated.
	GetResourceData(resourceName string) *CollectedResourceData
	// UpdateLinkDeploymentState updates the state of links that are pending completion
	// and returns a list of links that are ready to be deployed or updated.
	UpdateLinkDeploymentState(node *links.ChainLinkNode) []*LinkPendingCompletion
	// SetLinkDeployResult sets the result of the deployment of a link
	// to be used for persisting.
	// This is primarily meant to store the result
	// in ephemeral state straight after a link has been deployed to be
	// persisted later.
	SetLinkDeployResult(linkName string, result *LinkDeployResult)
	// GetLinkDeployResult returns the result of the deployment of a link.
	GetLinkDeployResult(linkName string) *LinkDeployResult
	// SetElementDependencies sets the dependencies of a resource or child blueprint
	// element in the deployment state.
	SetElementDependencies(element state.Element, dependencies *state.DependencyInfo)
	// GetElementDependencies returns the dependencies of a resource or child blueprint
	// element in the deployment state.
	GetElementDependencies(element state.Element) *state.DependencyInfo
}

type DeploymentStateFactory func() DeploymentState

type DeploymentUpdateMessage struct {
	// InstanceID is the ID of the blueprint instance
	// the message is associated with.
	InstanceID string `json:"instanceId"`
	// Status holds the status of the instance deployment.
	Status core.InstanceStatus `json:"status"`
	// UpdateTimestamp is the unix timestamp in seconds for
	// when the status update occurred.
	UpdateTimestamp int64 `json:"updateTimestamp"`
}

type DestroyInput struct {
	// InstanceID is the ID of the blueprint instance that will be destroyed.
	// If this is set, `InstanceName` must be empty.
	InstanceID string
	// InstanceName is the user-defined name of the blueprint instance
	// that will be destroyed.
	// If this is set, `InstanceID` must be empty.
	InstanceName string
	// Changes contains a description of all the elements that need to be
	// removed when destroying the blueprint instance.
	Changes *changes.BlueprintChanges
	// Rollback is used to indicate that the blueprint instance is being destroyed
	// as part of a rollback operation.
	// This is useful for ensuring the correct statuses are applied when changes within a child
	// blueprint need to be rolled back due to a failure in the parent blueprint.
	Rollback bool
}

type ElementWithAllDeps struct {
	Element state.Element
	// All collected dependencies for an element, both direct and transitive.
	// This is particularly useful for grouping a pre-sorted list of elements
	// to remove into sets of elements that can be processed in parallel.
	AllDependencies []state.Element
	// A list of direct dependencies for an element, particularly useful
	// for building a reference chain for sorting.
	DirectDependencies []state.Element
}

type EventType string

type ExpandedResourceTemplateResult struct {
	// ResourceTemplateMap is a map of resource template names
	// to the expanded resource names derived from the template.
	// This allows for looking up a resource in a template for substitution references
	// such as `resources.orderBucket[0]` without having to update references
	// as a part of resource template expansion.
	ResourceTemplateMap map[string][]string
	ExpandedBlueprint   *schema.Blueprint
}

type IncludeSubstitutionResolver interface {
	// ResolveInResource resolves substitutions in an include.
	ResolveInInclude(
		ctx context.Context,
		includeName string,
		include *schema.Include,
		resolveTargetInfo *subengine.ResolveIncludeTargetInfo,
	) (*subengine.ResolveInIncludeResult, error)
}

type LinkChangeStager interface {
	StageChanges(
		ctx context.Context,
		linkImpl provider.Link,
		currentResourceInfo *provider.ResourceInfo,
		readyToStage *LinkPendingCompletion,
		changeStagingState ChangeStagingState,
		linkChangesChan chan LinkChangesMessage,
		params core.BlueprintParams,
		logger core.Logger,
	) error
}

type LinkChangesMessage struct {
	ResourceAName string               `json:"resourceAName"`
	ResourceBName string               `json:"resourceBName"`
	Removed       bool                 `json:"removed"`
	New           bool                 `json:"new"`
	Changes       provider.LinkChanges `json:"changes"`
}

type LinkDeployResult struct {
	IntermediaryResourceStates []*state.LinkIntermediaryResourceState
	LinkData                   *core.MappingNode
}

type LinkDeployUpdateMessage struct {
	// InstanceID is the ID of the blueprint instance
	// the message is associated with.
	// As updates are sent for parent and child blueprints,
	// this ID is used to differentiate between them.
	InstanceID string `json:"instanceId"`
	// LinkID is the globally unique ID of the link.
	LinkID string `json:"linkId"`
	// LinkName is the logic name of the link in the blueprint.
	// This is a combination of the 2 resources that are linked.
	// For example, if a link is between a VPC and a subnet,
	// the link name would be "vpc::subnet".
	LinkName string `json:"linkName"`
	// Status holds the high-level status of the link.
	Status core.LinkStatus `json:"status"`
	// PreciseStatus holds the detailed status of the link.
	PreciseStatus core.PreciseLinkStatus `json:"preciseStatus"`
	// FailureReasons holds a list of reasons why the link failed to deploy
	// if the status update is for a failure.
	FailureReasons []string `json:"failureReasons,omitempty"`
	// Attempt is the current attempt number for applying the changes
	// for the current stage of the link deployment/removal.
	CurrentStageAttempt int `json:"currentStageAttempt"`
	// CanRetryCurrentStage indicates if the operation for the link can be retried
	// after this attempt of the current stage.
	CanRetryCurrentStage bool `json:"canRetryCurrentStage"`
	// UpdateTimestamp is the unix timestamp in seconds for
	// when the status update occurred.
	UpdateTimestamp int64 `json:"updateTimestamp"`
	// Durations holds duration information for a link deployment.
	// Duration information is attached on one of the following precise status updates:
	// - PreciseLinkStatusResourceAUpdated
	// - PreciseLinkStatusResourceAUpdateFailed
	// - PreciseLinkStatusResourceAUpdateRollbackFailed
	// - PreciseLinkStatusResourceAUpdateRollbackComplete
	// - PreciseLinkStatusResourceBUpdated
	// - PreciseLinkStatusResourceBUpdateFailed
	// - PreciseLinkStatusResourceBUpdateRollbackFailed
	// - PreciseLinkStatusResourceBUpdateRollbackComplete
	// - PreciseLinkStatusIntermediaryResourcesUpdated
	// - PreciseLinkStatusIntermediaryResourceUpdateFailed
	// - PreciseLinkStatusIntermediaryResourceUpdateRollbackFailed
	// - PreciseLinkStatusIntermediaryResourceUpdateRollbackComplete
	Durations *state.LinkCompletionDurations `json:"durations,omitempty"`
}

type LinkDeployer interface {
	Deploy(
		ctx context.Context,
		linkElement state.Element,
		instanceID string,
		linkUpdateType provider.LinkUpdateType,
		linkImplementation provider.Link,
		deployCtx *DeployContext,
		retryPolicy *provider.RetryPolicy,
	) error
}

type LinkDestroyer interface {
	Destroy(
		ctx context.Context,
		element state.Element,
		instanceID string,
		deployCtx *DeployContext,
	)
}

type LinkIDInfo struct {
	LinkID   string
	LinkName string
}

type LinkPendingCompletion struct {
	// contains filtered or unexported fields
}

type Loader interface {
	// Load deals with loading a blueprint specification from the local file system
	// along with provider and blueprint variables.
	// Provider and blueprint variables can be provided to the blueprint container
	// methods at a later stage, you can provide an empty set of parameters when
	// loading a spec.
	Load(
		ctx context.Context,
		blueprintSpecFile string,
		params bpcore.BlueprintParams,
	) (BlueprintContainer, error)

	// Validate deals with validating a specification that lies on the local
	// file system without loading a blueprint container.
	// Provider and blueprint variables can be provided for enhanced
	// validation that also checks variables.
	//
	// This also returns validation diagnostics for warning and info level
	// diagnostics that point out potential issues that may occur when executing
	// a blueprint. Diagnostics do not include errors, errors should be unpacked from
	// the returned error.
	Validate(
		ctx context.Context,
		blueprintSpecFile string,
		params bpcore.BlueprintParams,
	) (*ValidationResult, error)

	// LoadString deals with loading a blueprint specification from a string
	// along with provider and blueprint variables.
	// Provider and blueprint variables can be provided to the blueprint container
	// methods at a later stage, you can provide an empty set of parameters when
	// loading a spec.
	LoadString(
		ctx context.Context,
		blueprintSpec string,
		inputFormat schema.SpecFormat,
		params bpcore.BlueprintParams,
	) (BlueprintContainer, error)

	// ValidateString deals with validating a specification provided as a string
	// without loading a blueprint container.
	// Provider and blueprint variables can be provided for enhanced
	// validation that also checks variables.
	//
	// This also returns validation diagnostics for error, warning and info level
	// diagnostics that point out potential issues that may occur when executing
	// a blueprint. Diagnostics do not include all errors, errors should be unpacked from
	// the returned error in addition to the diagnostics.
	ValidateString(
		ctx context.Context,
		blueprintSpec string,
		inputFormat schema.SpecFormat,
		params bpcore.BlueprintParams,
	) (*ValidationResult, error)

	// LoadFromSchema deals with loading a blueprint specification from a schema
	// that has already been parsed along with provider and blueprint variables.
	// This is mostly useful for loading a blueprint from a schema cache to speed up
	// loading times, this is especially useful for blueprints that make use of a lot
	// ${..} substitutions and references.
	// Provider and blueprint variables can be provided to the blueprint container
	// methods at a later stage, you can provide an empty set of parameters when
	// loading a spec.
	LoadFromSchema(
		ctx context.Context,
		blueprintSchema *schema.Blueprint,
		params bpcore.BlueprintParams,
	) (BlueprintContainer, error)

	// ValidateFromSchema deals with validating a specification provided as a schema
	// without loading a blueprint container.
	// Provider and blueprint variables can be provided for enhanced
	// validation that also checks variables.
	//
	// This also returns validation diagnostics for error, warning and info level
	// diagnostics that point out potential issues that may occur when executing
	// a blueprint. Diagnostics do not include all errors, errors should be unpacked from
	// the returned error in addition to the diagnostics.
	ValidateFromSchema(
		ctx context.Context,
		blueprintSchema *schema.Blueprint,
		params bpcore.BlueprintParams,
	) (*ValidationResult, error)
}

type LoaderOption func(loader *defaultLoader)

type ResourceChangeStager interface {
	StageChanges(
		ctx context.Context,
		instanceID string,
		stagingState ChangeStagingState,
		node *links.ChainLinkNode,
		channels *ChangeStagingChannels,
		resourceProviders map[string]provider.Provider,
		params core.BlueprintParams,
		logger core.Logger,
	)
}

type ResourceChangesMessage struct {
	ResourceName    string           `json:"resourceName"`
	Removed         bool             `json:"removed"`
	New             bool             `json:"new"`
	Changes         provider.Changes `json:"changes"`
	ResolveOnDeploy []string         `json:"resolveOnDeploy"`
	// ConditionKnownOnDeploy is used to indicate that the condition for the resource
	// can not be resolved until the blueprint is deployed.
	// This means the changes described in this message may not be applied
	// if the condition evaluates to false when the blueprint is deployed.
	ConditionKnownOnDeploy bool `json:"conditionKnownOnDeploy"`
}

type ResourceDeployUpdateMessage struct {
	// InstanceID is the ID of the blueprint instance
	// the message is associated with.
	// As updates are sent for parent and child blueprints,
	// this ID is used to differentiate between them.
	InstanceID string `json:"instanceId"`
	// ResourceID is the globally unique ID of the resource.
	ResourceID string `json:"resourceId"`
	// ResourceName is the logical name of the resource
	// as defined in the source blueprint.
	ResourceName string `json:"resourceName"`
	// Group is the group number the resource belongs to relative to the ordering
	// for components in the current blueprint associated with the instance ID.
	// A group is a collection of items that can be deployed or destroyed at the same time.
	Group int `json:"group"`
	// Status holds the high-level status of the resource.
	Status core.ResourceStatus `json:"status"`
	// PreciseStatus holds the detailed status of the resource.
	PreciseStatus core.PreciseResourceStatus `json:"preciseStatus"`
	// FailureReasons holds a list of reasons why the resource failed to deploy
	// if the status update is for a failure.
	FailureReasons []string `json:"failureReasons,omitempty"`
	// Attempt is the current attempt number for deploying or destroying the resource.
	Attempt int `json:"attempt"`
	// CanRetry indicates if the operation for the resource can be retried
	// after this attempt.
	CanRetry bool `json:"canRetry"`
	// UpdateTimestamp is the unix timestamp in seconds for
	// when the status update occurred.
	UpdateTimestamp int64 `json:"updateTimestamp"`
	// Durations holds duration information for a resource deployment.
	// Duration information is attached on one of the following precise status updates:
	// - PreciseResourceStatusConfigComplete
	// - PreciseResourceStatusCreated
	// - PreciseResourceStatusCreateFailed
	// - PreciseResourceStatusCreateRollbackFailed
	// - PreciseResourceStatusCreateRollbackComplete
	// - PreciseResourceStatusDestroyed
	// - PreciseResourceStatusDestroyFailed
	// - PreciseResourceStatusDestroyRollbackFailed
	// - PreciseResourceStatusDestroyRollbackConfigComplete
	// - PreciseResourceStatusDestroyRollbackComplete
	// - PreciseResourceStatusUpdateConfigComplete
	// - PreciseResourceStatusUpdated
	// - PreciseResourceStatusUpdateFailed
	// - PreciseResourceStatusUpdateRollbackFailed
	// - PreciseResourceStatusUpdateRollbackConfigComplete
	// - PreciseResourceStatusUpdateRollbackComplete
	Durations *state.ResourceCompletionDurations `json:"durations,omitempty"`
}

type ResourceDeployer interface {
	Deploy(
		ctx context.Context,
		instanceID string,
		chainLinkNode *links.ChainLinkNode,
		changes *changes.BlueprintChanges,
		deployCtx *DeployContext,
	)
}

type ResourceDestroyer interface {
	Destroy(
		ctx context.Context,
		resourceElement state.Element,
		instanceID string,
		deployCtx *DeployContext,
	)
}

type ResourceIDInfo struct {
	ResourceID   string
	ResourceName string
}

type ResourceStabilityPollingConfig struct {
	// PollingInterval is the interval at which the resource will be polled
	// for stability.
	PollingInterval time.Duration
	// PollingTimeout is the maximum amount of time that the resource will be
	// polled for stability.
	PollingTimeout time.Duration
}

type ResourceSubstitutionResolver interface {
	// ResolveInResource resolves substitutions in a resource.
	ResolveInResource(
		ctx context.Context,
		resourceName string,
		resource *schema.Resource,
		resolveTargetInfo *subengine.ResolveResourceTargetInfo,
	) (*subengine.ResolveInResourceResult, error)
}

type StageChangesInput struct {
	// InstanceID is the ID of the blueprint instance that the changes will be applied to.
	// If this is set, `InstanceName` must be empty.
	InstanceID string
	// InstanceName is the user-defined name of the blueprint instance
	// that the changes will be applied to.
	// If this is set, `InstanceID` must be empty.
	InstanceName string
	// Destroy is used to indicate that the changes being staged should be for a destroy operation.
	// If this is set to true, the change set will be generated for removal all components
	// in the current state of the blueprint instance.
	Destroy bool
}

type ValidationResult struct {
	// Collected diagnostics from the validation process.
	Diagnostics []*bpcore.Diagnostic
	// The link information that was collected during validation.
	LinkInfo links.SpecLinkInfo
	// The parsed blueprint schema that was validated.
	Schema *schema.Blueprint
}