provider

type BadInputError struct {
	// The underlying error for that describes the bad input.
	ChildError     error
	FailureReasons []string
}

type Changes struct {
	// AppliedResourceInfo provides a new version of the spec
	// and schema for which variable substitution has been applied
	// so the deploy phase has everything it needs to deploy the resource.
	AppliedResourceInfo ResourceInfo  `json:"appliedResourceInfo"`
	MustRecreate        bool          `json:"mustRecreate"`
	ModifiedFields      []FieldChange `json:"modifiedFields"`
	NewFields           []FieldChange `json:"newFields"`
	RemovedFields       []string      `json:"removedFields"`
	UnchangedFields     []string      `json:"unchangedFields"`
	// ComputedFields holds a list of field paths that are computed
	// at deploy time. This is primarily useful to give fast access to
	// information about which fields are computed without having to inspect
	// the spec schema in link implementations.
	ComputedFields []string `json:"computedFields"`
	// FieldChangesKnownOnDeploy holds a list of field names
	// for which changes will be known when the host blueprint is deployed.
	FieldChangesKnownOnDeploy []string `json:"fieldChangesKnownOnDeploy"`
	// ConditionKnownOnDeploy specifies whether the condition
	// for the resource will be known when the host blueprint is deployed.
	// When a condition makes use of items in the blueprint that are not resolved
	// until deployment, whether the resource will be deployed or not
	// cannot be known during the change staging phase.
	ConditionKnownOnDeploy bool `json:"conditionKnownOnDeploy"`
	// NewOutboundLinks holds a mapping of the linked to resource name
	// to the link changes representing the new links that will be created.
	NewOutboundLinks map[string]LinkChanges `json:"newOutboundLinks"`
	// OutboundLinkChanges holds a mapping
	// of the linked to resource name to any changes
	// that will be made to existing links.
	// The key is of the form `{resourceA}::{resoureB}`
	OutboundLinkChanges map[string]LinkChanges `json:"outboundLinkChanges"`
	// RemovedOutboundLinks holds a list of link identifiers
	// that will be removed.
	// The form of the link identifier is `{resourceA}::{resoureB}`
	RemovedOutboundLinks []string `json:"removedOutboundLinks"`
}

type Context interface {
	// ProviderConfigVariable retrieves a configuration value that was loaded
	// for the current provider.
	ProviderConfigVariable(name string) (*core.ScalarValue, bool)
	// ProviderConfigVariables retrieves all the configuration values that were loaded
	// for the current provider.
	// This is useful to export all the configuration values to be sent to plugins
	// that are running in a different process.
	ProviderConfigVariables() map[string]*core.ScalarValue
	// ContextVariable retrieves a context-wide variable
	// for the current environment, this differs from values extracted
	// from context.Context, as these context variables are specific
	// to the components that implement the interfaces of the blueprint library
	// and can be shared between processes over a network or similar.
	ContextVariable(name string) (*core.ScalarValue, bool)
	// ContextVariables retrieves all the context-wide variables
	// for the current environment.
	// This is useful to export all the context-wide variables to be sent to plugins
	// that are running in a different process.
	ContextVariables() map[string]*core.ScalarValue
}

type CustomVariableType interface {
	// GetType deals with retrieving the namespaced type for a custom variable type.
	GetType(ctx context.Context, input *CustomVariableTypeGetTypeInput) (*CustomVariableTypeGetTypeOutput, error)
	// GetDescription deals with retrieving the description for a custom variable type in a blueprint spec
	// that can be used for documentation and tooling.
	// Markdown and plain text formats are supported.
	GetDescription(ctx context.Context, input *CustomVariableTypeGetDescriptionInput) (*CustomVariableTypeGetDescriptionOutput, error)
	// Options loads a set of fixed possible values available
	// for the custom variable type.
	// In the returned options, each one is keyed by a label, essentially
	// behaving as a runtime enum.
	Options(ctx context.Context, input *CustomVariableTypeOptionsInput) (*CustomVariableTypeOptionsOutput, error)
	// GetExamples loads a set of examples for how to use the custom
	// variable type in a blueprint.
	GetExamples(ctx context.Context, input *CustomVariableTypeGetExamplesInput) (*CustomVariableTypeGetExamplesOutput, error)
}

type CustomVariableTypeGetDescriptionInput struct {
	ProviderContext Context
}

type CustomVariableTypeGetDescriptionOutput struct {
	MarkdownDescription  string
	PlainTextDescription string
	// A short summary of the custom variable type that can be formatted
	// in markdown, this is useful for listing custom variable types in documentation.
	MarkdownSummary string
	// A short summary of the custom variable type in plain text,
	// this is useful for listing custom variable types in documentation.
	PlainTextSummary string
}

type CustomVariableTypeGetExamplesInput struct {
	ProviderContext Context
}

type CustomVariableTypeGetExamplesOutput struct {
	PlainTextExamples []string
	MarkdownExamples  []string
}

type CustomVariableTypeGetTypeInput struct {
	ProviderContext Context
}

type CustomVariableTypeGetTypeOutput struct {
	Type string
	// A human-readable label for the custom variable type.
	Label string
}

type CustomVariableTypeOption struct {
	// The value of the option.
	Value *core.ScalarValue
	// A human-readable label for the option.
	Label string
	// A human-readable plain text description for the option.
	Description string
	// A human-readable description for the option
	// that can be formatted in markdown.
	MarkdownDescription string
}

type CustomVariableTypeOptionsInput struct {
	ProviderContext Context
}

type CustomVariableTypeOptionsOutput struct {
	Options map[string]*CustomVariableTypeOption
}

type CustomVariableTypeRegistry interface {
	// GetDescription returns the description of a custom variable type
	// in the registry.
	GetDescription(
		ctx context.Context,
		customVariableType string,
		input *CustomVariableTypeGetDescriptionInput,
	) (*CustomVariableTypeGetDescriptionOutput, error)

	// HasCustomVariableType checks if a custom variable type is available in the registry.
	HasCustomVariableType(ctx context.Context, customVariableType string) (bool, error)

	// ListCustomVariableTypes retrieves a list of all the custom variable types avaiable
	// in the registry.
	ListCustomVariableTypes(ctx context.Context) ([]string, error)
}

type DataSource interface {
	// GetType deals with retrieving the namespaced type for a data source in a blueprint.
	GetType(ctx context.Context, input *DataSourceGetTypeInput) (*DataSourceGetTypeOutput, error)
	// GetTypeDescription deals with retrieving the description for a data source type in a blueprint spec
	// that can be used for documentation and tooling.
	// Markdown and plain text formats are supported.
	GetTypeDescription(ctx context.Context, input *DataSourceGetTypeDescriptionInput) (*DataSourceGetTypeDescriptionOutput, error)
	// CustomValidate provides support for custom validation that goes beyond
	// the spec schema validation provided by the data source's spec definition.
	CustomValidate(ctx context.Context, input *DataSourceValidateInput) (*DataSourceValidateOutput, error)
	// GetSpecDefinition retrieves the spec definition for a data source.
	// This definition specifies all the fields that can be exported from a data source
	// to be used in a blueprint.
	// This is the first line of validation for a data source in a blueprint and is also
	// useful for validating references to a data source instance
	// in a blueprint and for providing definitions for docs and tooling.
	GetSpecDefinition(ctx context.Context, input *DataSourceGetSpecDefinitionInput) (*DataSourceGetSpecDefinitionOutput, error)
	// GetFilterFields provides the fields that can be used in a filter for a data source.
	GetFilterFields(ctx context.Context, input *DataSourceGetFilterFieldsInput) (*DataSourceGetFilterFieldsOutput, error)
	// Fetch deals with loading the data from the upstream data source
	// and returning the exported fields defined in the spec.
	Fetch(ctx context.Context, input *DataSourceFetchInput) (*DataSourceFetchOutput, error)
	// GetExamples deals with retrieving a list examples for a data source type in a blueprint spec
	// that can be used for documentation and tooling.
	// Markdown and plain text formats are supported.
	GetExamples(ctx context.Context, input *DataSourceGetExamplesInput) (*DataSourceGetExamplesOutput, error)
}

type DataSourceFetchInput struct {
	// DataSourceWithResolvedSubs holds a version of a data source for which all ${..}
	// substitutions have been applied.
	DataSourceWithResolvedSubs *ResolvedDataSource
	ProviderContext            Context
}

type DataSourceFetchOutput struct {
	Data map[string]*core.MappingNode
}

type DataSourceFilterSchema struct {
	// Type holds the type of the data source filter field.
	Type DataSourceFilterSearchValueType
	// Description holds a human-readable description for the data source spec
	// without any formatting.
	Description string
	// FormattedDescription holds a human-readable description for the data source spec
	// that is formatted with markdown.
	FormattedDescription string
	// A list of supported operators for the filter field, this will be used
	// for validation and documentation to ensure that only operators
	// supported by a specific data source filter are used.
	SupportedOperators []schema.DataSourceFilterOperator
	// A list of other filter fields that this filter field conflicts with.
	// For example, when an external resource can have multiple unique identifiers,
	// you will usually want to ensure that only one of them is used in a filter
	// at a time, so you can specify the conflicting filter fields here.
	ConflictsWith []string
}

type DataSourceFilterSearchValueType string

type DataSourceGetExamplesInput struct {
	ProviderContext Context
}

type DataSourceGetExamplesOutput struct {
	MarkdownExamples  []string
	PlainTextExamples []string
}

type DataSourceGetFilterFieldsInput struct {
	ProviderContext Context
}

type DataSourceGetFilterFieldsOutput struct {
	// A map of filter field names to a definition that includes descriptions
	// and a schema for the filter field used for documentation and validation.
	FilterFields map[string]*DataSourceFilterSchema
}

type DataSourceGetSpecDefinitionInput struct {
	ProviderContext Context
}

type DataSourceGetSpecDefinitionOutput struct {
	SpecDefinition *DataSourceSpecDefinition
}

type DataSourceGetTypeDescriptionInput struct {
	ProviderContext Context
}

type DataSourceGetTypeDescriptionOutput struct {
	MarkdownDescription  string
	PlainTextDescription string
	// A short summary of the data source type that can be formatted
	// in markdown, this is useful for listing data source types in documentation.
	MarkdownSummary string
	// A short summary of the data source type in plain text,
	// this is useful for listing data source types in documentation.
	PlainTextSummary string
}

type DataSourceGetTypeInput struct {
	ProviderContext Context
}

type DataSourceGetTypeOutput struct {
	Type string
	// A human-readable label for the data source type.
	Label string
}

type DataSourceRegistry interface {
	// GetSpecDefinition returns the definition of a data source spec
	// in the registry that includes allowed parameters and return types.
	GetSpecDefinition(
		ctx context.Context,
		dataSourceType string,
		input *DataSourceGetSpecDefinitionInput,
	) (*DataSourceGetSpecDefinitionOutput, error)

	// GetFilterFields returns the fields that can be used in a filter for a data source.
	GetFilterFields(
		ctx context.Context,
		dataSourceType string,
		input *DataSourceGetFilterFieldsInput,
	) (*DataSourceGetFilterFieldsOutput, error)

	// GetTypeDescription returns the description of a data source type
	// in the registry.
	GetTypeDescription(
		ctx context.Context,
		dataSourceType string,
		input *DataSourceGetTypeDescriptionInput,
	) (*DataSourceGetTypeDescriptionOutput, error)

	// HasDataSourceType checks if a data source type is available in the registry.
	HasDataSourceType(ctx context.Context, dataSourceType string) (bool, error)

	// ListDataSourceTypes retrieves a list of all the data source types avaiable
	// in the registry.
	ListDataSourceTypes(ctx context.Context) ([]string, error)

	// CustomValidate allows for custom validation of a data source of a given type.
	CustomValidate(
		ctx context.Context,
		dataSourceType string,
		input *DataSourceValidateInput,
	) (*DataSourceValidateOutput, error)

	// Fetch retrieves the data from a data source using the provider
	// of the given type.
	Fetch(
		ctx context.Context,
		dataSourceType string,
		input *DataSourceFetchInput,
	) (*DataSourceFetchOutput, error)
}

type DataSourceSpecDefinition struct {
	// Fields holds a mapping of schemas for
	// fields that can be exported from a data source.
	// Unlike resource specs, data source specs are restricted
	// in that they only support primitives or arrays of primitives.
	Fields map[string]*DataSourceSpecSchema
}

type DataSourceSpecSchema struct {
	// Type holds the type of the data source spec.
	Type DataSourceSpecSchemaType
	// Label holds a human-readable label for the data source spec.
	Label string
	// Description holds a human-readable description for the data source spec
	// without any formatting.
	Description string
	// FormattedDescription holds a human-readable description for the data source spec
	// that is formatted with markdown.
	FormattedDescription string
	// Items holds the schema for the items in a data source spec schema array.
	// Items are expected to be of a primitive type, if an array type is provided here,
	// an error will occur.
	Items *DataSourceSpecSchema
	// Nullable specifies whether the data source spec schema can be null.
	// This essentially means that the data source implementation can provide
	// a null value for the field.
	Nullable bool
}

type DataSourceSpecSchemaType string

type DataSourceValidateInput struct {
	SchemaDataSource *schema.DataSource
	ProviderContext  Context
}

type DataSourceValidateOutput struct {
	Diagnostics []*core.Diagnostic
}

type ErrorFailureReasons interface {
	GetFailureReasons() []string
}

type FieldChange struct {
	FieldPath string            `json:"fieldPath"`
	PrevValue *core.MappingNode `json:"prevValue"`
	NewValue  *core.MappingNode `json:"newValue"`
	// MustRecreate is a flag that indicates whether the resource or link
	// containing the field must be recreated in order to apply the change.
	MustRecreate bool `json:"mustRecreate"`
}

type Function interface {
	// GetDefinition returns the definition of the function
	// that includes allowed parameters and return types.
	// This would usually be called during initialisation of a provider
	// to pre-fetch function definitions and cache them to validate
	// the returned values from plugin function calls.
	GetDefinition(ctx context.Context, input *FunctionGetDefinitionInput) (*FunctionGetDefinitionOutput, error)
	// Call is the function that is called when a function is used in a blueprint.
	// Tools built on top of the framework should provide custom error types
	// that can be used to distinguish logical function call errors from other
	// errors that may occur during a function call.
	Call(ctx context.Context, input *FunctionCallInput) (*FunctionCallOutput, error)
}

type FunctionCallArguments interface {
	// Get retrieves the argument at the given position.
	Get(ctx context.Context, position int) (any, error)
	// GetVar writes the argument at the given position to the
	// provided target.
	GetVar(ctx context.Context, position int, target any) error
	// GetMultipleVars writes the arguments to the provided targets
	// in the order they were passed to the function.
	GetMultipleVars(ctx context.Context, targets ...any) error
	// Export captures the arguments for the current context
	// as a slice of any that can be serialised and transported
	// across process boundaries.
	Export(ctx context.Context) ([]any, error)
}

type FunctionCallContext interface {
	// Registry retrieves the function registry that can be used to
	// call other functions from within a function.
	// This would be akin to importing functions from a module
	// to be called in a typical programming language.
	Registry() FunctionRegistry
	// Params retrieves the current context blueprint params
	// treated like global data from the perspective of function
	// implementations.
	Params() core.BlueprintParams
	// NewCallArgs creates a new instance of FunctionCallArguments
	// to be passed into a function call.
	NewCallArgs(args ...any) FunctionCallArguments
	// CallStackSnapshot provides a snapshot of the current call stack
	// to be used in error messages.
	CallStackSnapshot() []*function.Call
	// CurrentLocation provides the current location in the blueprint
	// where the function is being called.
	// This can be used to associate a function call with a specific
	// location in the source blueprint, this can and often will yield
	// nil in situations where the location is not available.
	CurrentLocation() *source.Meta
}

type FunctionCallInput struct {
	Arguments   FunctionCallArguments
	CallContext FunctionCallContext
}

type FunctionCallOutput struct {
	ResponseData any
	FunctionInfo FunctionRuntimeInfo
}

type FunctionGetDefinitionInput struct {
	Params core.BlueprintParams
}

type FunctionGetDefinitionOutput struct {
	Definition *function.Definition
}

type FunctionRegistry interface {
	// ForCallContext creates a light-weight copy of the registry
	// with a call stack that is specific to the current call context
	// (i.e. a ${..} substitution).
	ForCallContext(stack function.Stack) FunctionRegistry

	// Call allows calling a function in the registry by name.
	Call(ctx context.Context, functionName string, input *FunctionCallInput) (*FunctionCallOutput, error)

	// GetDefinition returns the definition of a function
	// in the registry that includes allowed parameters and return types.
	GetDefinition(
		ctx context.Context,
		functionName string,
		input *FunctionGetDefinitionInput,
	) (*FunctionGetDefinitionOutput, error)

	// HasFunction checks if a function is available in the registry.
	HasFunction(ctx context.Context, functionName string) (bool, error)

	// ListFunctions retrieves a list of all the functions avaiable
	// in the registry.
	ListFunctions(ctx context.Context) ([]string, error)
}

type FunctionRuntimeInfo struct {
	FunctionName string
	PartialArgs  []any
	// Specify the offset of the arguments in the partial arguments.
	// This should be rarely be used, but in the case where the captured
	// arguments to be "partially applied" are not the first arguments
	// in the function signature, this can be used to specify the offset
	// of the arguments in the partial arguments list.
	ArgsOffset int
}

type Link interface {
	// StageChanges must detail the changes that will be made when a deployment of the loaded blueprint
	// for the link between two resources.
	// Unlike resources, links do not map to a specification for a single deployable unit,
	// so link implementations must specify the changes that will be made across multiple resources.
	StageChanges(
		ctx context.Context,
		input *LinkStageChangesInput,
	) (*LinkStageChangesOutput, error)
	// UpdateResourceA deals with applying the changes to the first of the two linked resources
	// for the creation or removal of a link between two resources.
	// The value of the `LinkData` field returned in the output will be combined
	// with the LinkData output from updating resource B and intermediary resources
	// to form the final LinkData that will be persisted in the state of the blueprint instance.
	// Parameters are passed into UpdateResourceA for extra context, blueprint variables will have already
	// been substituted at this stage and must be used instead of the passed in params argument
	// to ensure consistency between the staged changes that are reviewed and the deployment itself.
	UpdateResourceA(ctx context.Context, input *LinkUpdateResourceInput) (*LinkUpdateResourceOutput, error)
	// UpdateResourceB deals with applying the changes to the second of the two linked resources
	// for the creation or removal of a link between two resources.
	// The value of the `LinkData` field returned in the output will be combined
	// with the LinkData output from updating resource A and intermediary resources
	// to form the final LinkData that will be persisted in the state of the blueprint instance.
	// Parameters are passed into UpdateResourceB for extra context, blueprint variables will have already
	// been substituted at this stage and must be used instead of the passed in params argument
	// to ensure consistency between the staged changes that are reviewed and the deployment itself.
	UpdateResourceB(ctx context.Context, input *LinkUpdateResourceInput) (*LinkUpdateResourceOutput, error)
	// UpdateIntermediaryResources deals with creating, updating or deleting intermediary resources
	// that are required for the link between two resources.
	// This is called for both the creation and removal of a link between two resources.
	// The value of the `LinkData` field returned in the output will be combined
	// with the LinkData output from updating resource A and B
	// to form the final LinkData that will be persisted in the state of the blueprint instance.
	// Parameters are passed into UpdateIntermediaryResources for extra context, blueprint variables will have already
	// been substituted at this stage and must be used instead of the passed in params argument
	// to ensure consistency between the staged changes that are reviewed and the deployment itself.
	UpdateIntermediaryResources(
		ctx context.Context,
		input *LinkUpdateIntermediaryResourcesInput,
	) (*LinkUpdateIntermediaryResourcesOutput, error)
	// GetPriorityResource retrieves the resource in the relationship
	// that must be deployed first. This will be empty for links where one resource does not
	// need to be deployed before the other.
	GetPriorityResource(ctx context.Context, input *LinkGetPriorityResourceInput) (*LinkGetPriorityResourceOutput, error)
	// GetType deals with retrieving the type of the link in relation to the two resource
	// types it provides a relationship between.
	GetType(ctx context.Context, input *LinkGetTypeInput) (*LinkGetTypeOutput, error)
	// GetTypeDescription deals with retrieving the description for a link type in a blueprint spec
	// that can be used for documentation and tooling.
	// Markdown and plain text formats are supported.
	GetTypeDescription(ctx context.Context, input *LinkGetTypeDescriptionInput) (*LinkGetTypeDescriptionOutput, error)
	// GetAnnotationDefinitions retrieves the annotation definitions for the link type.
	// Annotations provide a way to fine tune the behaviour of a link in a blueprint spec
	// in the linked resource metadata sections.
	GetAnnotationDefinitions(ctx context.Context, input *LinkGetAnnotationDefinitionsInput) (*LinkGetAnnotationDefinitionsOutput, error)
	// GetKind tells us whether the link is a "hard" or "soft" link.
	// A hard link is where the priority resource type must be created first.
	// A soft link is where it does not matter which resource type in the relationship
	// is created first.
	GetKind(ctx context.Context, input *LinkGetKindInput) (*LinkGetKindOutput, error)
}

type LinkAnnotationDefinition struct {
	Name          string              `json:"name"`
	Label         string              `json:"label"`
	Type          core.ScalarType     `json:"type"`
	Description   string              `json:"description"`
	DefaultValue  *core.ScalarValue   `json:"defaultValue,omitempty"`
	AllowedValues []*core.ScalarValue `json:"allowedValues,omitempty"`
	Examples      []*core.ScalarValue `json:"examples,omitempty"`
	Required      bool                `json:"required"`
	// ValidateFunc is a custom validation function that allows for validation
	// of annotation values when provided as literals.
	// When substitutions are used as annotation values (e.g. `${variables.myVar}`),
	// the validation function will not be called, as the value will not be resolved
	// to a concrete value at the validation stage.
	// The function should return a slice of diagnostics, where if at least one diagnostic
	// has a level of Error, overall validation will fail.
	ValidateFunc func(
		key string,
		annotationValue *core.ScalarValue,
	) []*core.Diagnostic `json:"-"`
}

type LinkChanges struct {
	ModifiedFields  []*FieldChange `json:"modifiedFields"`
	NewFields       []*FieldChange `json:"newFields"`
	RemovedFields   []string       `json:"removedFields"`
	UnchangedFields []string       `json:"unchangedFields"`
	// FieldChangesKnownOnDeploy holds a list of field names
	// for which changes will be known when the host blueprint is deployed.
	FieldChangesKnownOnDeploy []string `json:"fieldChangesKnownOnDeploy"`
}

type LinkContext interface {
	// ProviderConfigVariable retrieves a configuration value that was loaded
	// for the specified provider.
	ProviderConfigVariable(providerNamespace string, varName string) (*core.ScalarValue, bool)
	// ProviderConfigVariables retrieves all configuration values that were loaded
	// for the specified provider.
	ProviderConfigVariables(providerNamespace string) map[string]*core.ScalarValue
	// AllProviderConfigVariables retrieves all configuration values that were loaded
	// for all providers.
	AllProviderConfigVariables() map[string]map[string]*core.ScalarValue
	// ContextVariable retrieves a context-wide variable
	// for the current environment, this differs from values extracted
	// from context.Context, as these context variables are specific
	// to the components that implement the interfaces of the blueprint library
	// and can be shared between processes over a network or similar.
	ContextVariable(name string) (*core.ScalarValue, bool)
	// ContextVariables returns all context variables
	// for the current environment.
	ContextVariables() map[string]*core.ScalarValue
}

type LinkGetAnnotationDefinitionsInput struct {
	LinkContext LinkContext
}

type LinkGetAnnotationDefinitionsOutput struct {
	// A mapping of annotation names prefixed by resource type that
	// can be used to fine tune the behaviour of a link in a blueprint spec.
	// The format should be as follows:
	// {resourceType}::{annotationName} -> LinkAnnotationDefinition
	// e.g. "aws/lambda/function::aws.lambda.dynamodb.accessType" -> LinkAnnotationDefinition
	AnnotationDefinitions map[string]*LinkAnnotationDefinition
}

type LinkGetKindInput struct {
	LinkContext LinkContext
}

type LinkGetKindOutput struct {
	Kind LinkKind
}

type LinkGetPriorityResourceInput struct {
	LinkContext LinkContext
}

type LinkGetPriorityResourceOutput struct {
	PriorityResource     LinkPriorityResource
	PriorityResourceType string
}

type LinkGetTypeDescriptionInput struct {
	LinkContext LinkContext
}

type LinkGetTypeDescriptionOutput struct {
	MarkdownDescription  string
	PlainTextDescription string
	// A short summary of the link type that can be formatted
	// in markdown, this is useful for listing link types in documentation.
	MarkdownSummary string
	// A short summary of the link type in plain text,
	// this is useful for listing link types in documentation.
	PlainTextSummary string
}

type LinkGetTypeInput struct {
	LinkContext LinkContext
}

type LinkGetTypeOutput struct {
	Type string
}

type LinkKind string

type LinkPriorityResource int

type LinkRegistry interface {
	// Link retrieves a link plugin to handle a link between two resource types
	// in a blueprint from one of the registered providers.
	Link(ctx context.Context, resourceTypeA string, resourceTypeB string) (Link, error)
	// Provider retrieves the provider that implements the link between two resource types.
	Provider(resourceTypeA string, resourceTypeB string) (Provider, error)
}

type LinkStageChangesInput struct {
	ResourceAChanges *Changes
	ResourceBChanges *Changes
	CurrentLinkState *state.LinkState
	LinkContext      LinkContext
}

type LinkStageChangesOutput struct {
	Changes *LinkChanges
}

type LinkUpdateIntermediaryResourcesError struct {
	FailureReasons []string
	ChildError     error
}

type LinkUpdateIntermediaryResourcesInput struct {
	ResourceAInfo *ResourceInfo
	ResourceBInfo *ResourceInfo
	Changes       *LinkChanges
	// Additional user-defined blueprint instance name
	// that can be used in ID/unique name generation and for debugging.
	InstanceName   string
	LinkUpdateType LinkUpdateType
	LinkContext    LinkContext
	// ResourceDeployService allows a link implementation to hook into
	// the framework's existing mechanism to manage resource deployments,
	// this is useful as it allows link implementations to use the same
	// resources used in blueprints.
	ResourceDeployService ResourceDeployService
}

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

type LinkUpdateResourceAError struct {
	FailureReasons []string
	ChildError     error
}

type LinkUpdateResourceBError struct {
	FailureReasons []string
	ChildError     error
}

type LinkUpdateResourceInput struct {
	Changes           *LinkChanges
	ResourceInfo      *ResourceInfo
	OtherResourceInfo *ResourceInfo
	// Additional user-defined blueprint instance name
	// that can be used in ID/unique name generation and for debugging.
	InstanceName   string
	LinkUpdateType LinkUpdateType
	LinkContext    LinkContext
}

type LinkUpdateResourceOutput struct {
	LinkData *core.MappingNode
}

type LinkUpdateType int

type Provider interface {
	// Namespace retrieves the resource type prefix that is used as the namespace
	// for all resource types in the provider.
	// (e.g. "aws" for AWS resources such as "aws/lambda/function")
	Namespace(ctx context.Context) (string, error)
	// ConfigDefinition retrieves a detailed definition of the
	// configuration that is required for the provider.
	ConfigDefinition(ctx context.Context) (*core.ConfigDefinition, error)
	// Resource retrieves a resource plugin to handle a resource in a blueprint for
	// a given resource type.
	Resource(ctx context.Context, resourceType string) (Resource, error)
	// DataSource retrieves a data source plugin to handle a data source in a blueprint
	// for a given data source type.
	DataSource(ctx context.Context, dataSourceType string) (DataSource, error)
	// Link retrieves a link plugin to handle a link between two resource types
	// in a blueprint.
	Link(ctx context.Context, resourceTypeA string, resourceTypeB string) (Link, error)
	// CustomVariableType retrieves a custom variable type plugin to handle validating
	// convenience variable types with a (usually large) fixed set of possible values.
	// These custom variable types should not be used for dynamically sourced values
	// external to a blueprint, data sources exist for that purpose.
	CustomVariableType(ctx context.Context, customVariableType string) (CustomVariableType, error)
	// Function retrieves a function plugin that provides custom pure functions for blueprint
	// substitutions "${..}".
	// Functions are global and which providers are to be used for which functions
	// should be configured during initialisation of an application using the framework.
	// The core functions that are defined in the blueprint specification can not be overridden
	// by a provider.
	Function(ctx context.Context, functionName string) (Function, error)
	// ListResourceTypes retrieves a list of all the resource types that are provided by the
	// provider. This is primarily used in tools and documentation to provide a list of
	// available resource types.
	ListResourceTypes(ctx context.Context) ([]string, error)
	// ListLinkTypes retrieves a list of all the link types that are provided by the
	// provider. This is primarily used in tools and documentation to provide a list of
	// available link types.
	ListLinkTypes(ctx context.Context) ([]string, error)
	// ListDataSourceTypes retrieves a list of all the data source types that are provided by the
	// provider. This is primarily used in tools and documentation to provide a list of
	// available data source types.
	ListDataSourceTypes(ctx context.Context) ([]string, error)
	// ListCustomVariableTypes retrieves a list of all the custom variable types that are provided by the
	// provider. This is primarily used in tools and documentation to provide a list of
	// available custom variable types.
	ListCustomVariableTypes(ctx context.Context) ([]string, error)
	// ListFunctions retrieves a list of all the function names that are provided by the
	// provider. This is primarily used to assign the correct provider to a function
	// as functions are globally named. When multiple providers provide the same function,
	// an error should be reported during initialisation.
	ListFunctions(ctx context.Context) ([]string, error)
	// RetryPolicy retrieves the retry policy that should be used for the provider
	// for resource, link and data source operations.
	// The retry policy will be applied for resources when deploying, updating and removing
	// resources, for links when creating and removing links and for data sources when
	// querying the upstream data source.
	// The retry behaviour only kicks in when the provider resource, data source or link
	// implementation returns an error of type `provider.RetryableError`,
	// in which case the retry policy will be applied.
	// A retry policy is optional and if not provided, a default retry policy
	// provided by the host tool will be used.
	RetryPolicy(ctx context.Context) (*RetryPolicy, error)
}

type ResolvedDataSource struct {
	Type               *schema.DataSourceTypeWrapper             `json:"type"`
	DataSourceMetadata *ResolvedDataSourceMetadata               `json:"metadata"`
	Filter             *ResolvedDataSourceFilters                `json:"filter"`
	Exports            map[string]*ResolvedDataSourceFieldExport `json:"exports"`
	Description        *core.MappingNode                         `json:"description,omitempty"`
}

type ResolvedDataSourceFieldExport struct {
	Type        *schema.DataSourceFieldTypeWrapper `json:"type"`
	AliasFor    *core.ScalarValue                  `json:"aliasFor,omitempty"`
	Description *core.MappingNode                  `json:"description,omitempty"`
}

type ResolvedDataSourceFilter struct {
	Field    *core.ScalarValue                       `json:"field"`
	Operator *schema.DataSourceFilterOperatorWrapper `json:"operator"`
	Search   *ResolvedDataSourceFilterSearch         `json:"search"`
}

type ResolvedDataSourceFilterSearch struct {
	Values []*core.MappingNode
}

type ResolvedDataSourceFilters struct {
	Filters []*ResolvedDataSourceFilter `json:"filters"`
}

type ResolvedDataSourceMetadata struct {
	DisplayName *core.MappingNode `json:"displayName"`
	Annotations *core.MappingNode `json:"annotations,omitempty"`
	Custom      *core.MappingNode `json:"custom,omitempty"`
}

type ResolvedResource struct {
	Type         *schema.ResourceTypeWrapper `json:"type"`
	Description  *core.MappingNode           `json:"description,omitempty"`
	Metadata     *ResolvedResourceMetadata   `json:"metadata,omitempty"`
	Condition    *ResolvedResourceCondition  `json:"condition,omitempty"`
	LinkSelector *schema.LinkSelector        `json:"linkSelector,omitempty"`
	Spec         *core.MappingNode           `json:"spec"`
}

type ResolvedResourceCondition struct {
	// A list of conditions that must all be true.
	And []*ResolvedResourceCondition `json:"and,omitempty"`
	// A list of conditions where at least one must be true.
	Or []*ResolvedResourceCondition `json:"or,omitempty"`
	// A condition that will be negated.
	Not *ResolvedResourceCondition `json:"not,omitempty"`
	// A condition expression that is expected
	// to be a substitution that resolves to a boolean.
	StringValue *core.MappingNode `json:"-"`
}

type ResolvedResourceMetadata struct {
	DisplayName *core.MappingNode `json:"displayName,omitempty"`
	Annotations *core.MappingNode `json:"annotations,omitempty"`
	Labels      *schema.StringMap `json:"labels,omitempty"`
	Custom      *core.MappingNode `json:"custom,omitempty"`
}

type Resource interface {
	// CustomValidate provides support for custom validation that goes beyond
	// the spec schema validation provided by the resource's spec definition.
	CustomValidate(ctx context.Context, input *ResourceValidateInput) (*ResourceValidateOutput, error)
	// GetSpecDefinition retrieves the spec definition for a resource,
	// this is the first line of validation for a resource in a blueprint and is also
	// useful for validating references to a resource instance
	// in a blueprint and for providing definitions for docs and tooling.
	// The spec defines both the schema for the resource spec fields that can be defined
	// by users in a blueprint and computed fields that are derived from the deployed
	// resource in the external provider (e.g. Lambda ARN in AWS).
	GetSpecDefinition(ctx context.Context, input *ResourceGetSpecDefinitionInput) (*ResourceGetSpecDefinitionOutput, error)
	// CanLinkTo specifices the list of resource types the current resource type
	// can link to.
	CanLinkTo(ctx context.Context, input *ResourceCanLinkToInput) (*ResourceCanLinkToOutput, error)
	// GetStabilisedDependencies retrieves a list of resource types that must be stabilised
	// before the current resource can be deployed when another resource of one of the specified types
	// is a dependency of the current resource in a blueprint.
	GetStabilisedDependencies(ctx context.Context, input *ResourceStabilisedDependenciesInput) (*ResourceStabilisedDependenciesOutput, error)
	// IsCommonTerminal specifies whether this resource is expected to have a common use-case
	// as a terminal resource that does not link out to other resources.
	// This is useful for providing useful warnings to users about their blueprints
	// without overloading them with warnings for all resources that don't have any outbound
	// links that could have.
	IsCommonTerminal(ctx context.Context, input *ResourceIsCommonTerminalInput) (*ResourceIsCommonTerminalOutput, error)
	// GetType deals with retrieving the namespaced type for a resource in a blueprint spec.
	GetType(ctx context.Context, input *ResourceGetTypeInput) (*ResourceGetTypeOutput, error)
	// GetTypeDescription deals with retrieving the description for a resource type in a blueprint spec
	// that can be used for documentation and tooling.
	// Markdown and plain text formats are supported.
	GetTypeDescription(ctx context.Context, input *ResourceGetTypeDescriptionInput) (*ResourceGetTypeDescriptionOutput, error)
	// GetExamples deals with retrieving a list of examples for a resource type in a blueprint spec
	// that can be used for documentation and tooling.
	// Markdown and plain text formats are supported.
	GetExamples(ctx context.Context, input *ResourceGetExamplesInput) (*ResourceGetExamplesOutput, error)
	// Deploy deals with deploying a resource with the upstream resource provider.
	// The behaviour of deploy is to create or update the resource configuration and return the resource
	// spec state once the configuration has been created or updated.
	// Deploy should not wait for the resource to be in a stable state before returning,
	// the framework will call the HasStabilised method periodically when waiting for a resource
	// to stabilise.
	// Parameters are passed into Deploy for extra context, blueprint variables will have already
	// been substituted at this stage and must be used instead of the passed in params argument
	// to ensure consistency between the staged changes that are reviewed and the deployment itself.
	Deploy(ctx context.Context, input *ResourceDeployInput) (*ResourceDeployOutput, error)
	// HasStabilised deals with checking if a resource has stabilised after being deployed.
	// This is important for resources that require a stable state before other resources can be deployed.
	// This is only used when creating or updating a resource, not when destroying a resource.
	HasStabilised(ctx context.Context, input *ResourceHasStabilisedInput) (*ResourceHasStabilisedOutput, error)
	// GetExternalState deals with getting the state of the resource from the resource provider.
	// (e.g. AWS or Google Cloud)
	GetExternalState(ctx context.Context, input *ResourceGetExternalStateInput) (*ResourceGetExternalStateOutput, error)
	// Destroy deals with destroying a resource instance if its current
	// state is successfully deployed or cleaning up a corrupt or partially deployed
	// resource instance.
	// The resource instance should be completely removed from the external provider
	// as a result of this operation; this is essential for when
	// another element to be removed from a blueprint
	// requires a resource to be completely removed from the external provider.
	// There is no "config complete" equivalent for destroying a resource and
	// "HasStabilised" is designed to be used for resources being created or
	// updated.
	Destroy(ctx context.Context, input *ResourceDestroyInput) error
}

type ResourceCanLinkToInput struct {
	ProviderContext Context
}

type ResourceCanLinkToOutput struct {
	CanLinkTo []string
}

type ResourceDefinitionsSchema struct {
	// Type holds the type of the resource definition.
	Type ResourceDefinitionsSchemaType
	// Label holds a human-readable label for the resource definition.
	Label string
	// Description holds a human-readable description for the resource definition
	// without any formatting.
	Description string
	// FormattedDescription holds a human-readable description for the resource definition
	// that is formatted with markdown.
	FormattedDescription string
	// Attributes holds a mapping of the attribute types for a resource definition
	// schema object.
	Attributes map[string]*ResourceDefinitionsSchema
	// Items holds the schema for the items in a resource definition schema array.
	Items *ResourceDefinitionsSchema
	// MapValues holds the schema for the values in a resource definition schema map.
	// Keys are always strings.
	MapValues *ResourceDefinitionsSchema
	// OneOf holds a list of possible schemas for a resource definition item.
	// This is to be used with the "union" type.
	OneOf []*ResourceDefinitionsSchema
	// Required holds a list of required attributes for a resource definition schema object.
	Required []string
	// Nullable specifies whether the resource definition schema can be null.
	Nullable bool
	// AllowedValues holds a list of allowed values for a resource definition schema.
	// This is useful for enum-like values and can be used with the "string",
	// "integer" and "float" types.
	// Unions and enums are mutually exclusive, when designing your schemas,
	// you should use either unions for type constraints or allowed values for
	// value constraints.
	// In the validation implementation, the allowed values constraint will only be applied
	// for values that contain ${..} substitutions, warnings will be produced when the value
	// contains substitutions as there is no way to know the final value during the validation phase.
	// Allowed values take precedence over other value constrants such as minimum, maximum and pattern.
	AllowedValues []*core.MappingNode
	// Minimum holds the minimum value that can be used for an element in a resource spec that uses
	// this schema.
	// This is only used for "integer" and "float" types.
	// This constraint can not be forced when ${..} substitutions are used in a value,
	// warnings will be produced when the value contains substitutions
	// as there is no way to know the final value during the validation phase.
	// Allowed values will take precedence over this constraint.
	Minimum *core.ScalarValue
	// Maximum holds the maximum value that can be used for an element in a resource spec that uses
	// this schema.
	// This is only used for "integer" and "float" types.
	// This constraint can not be forced when ${..} substitutions are used in a value,
	// warnings will be produced when the value contains substitutions
	// as there is no way to know the final value during the validation phase.
	// Allowed values will take precedence over this constraint.
	Maximum *core.ScalarValue
	// MinLength can provide a minimum length for a string value,
	// minimum amount of items in an array or minimum number of keys in a map.
	// This is only used for "string", "array" and "map" types.
	//
	// For strings, this constraint represents the minimum number of characters (runes)
	// in the string and not the number of bytes.
	//
	// This constraint can not be forced when ${..} substitutions are used in a string value,
	// warnings will be produced when a string value contains substitutions
	// as there is no way to know the final value during the validation phase.
	// 0 means that there is no minimum length constraint.
	// Allowed values will take precedence over this constraint for values of type "string".
	MinLength int
	// MaxLength can provide a maximum length for a string value,
	// maximum amount of items in an array or maximum number of keys in a map.
	// This is only used for "string", "array" and "map" types.
	//
	// For strings, this constraint represents the maximum number of characters (runes)
	// in the string and not the number of bytes.
	//
	// This constraint can not be forced when ${..} substitutions are used in a string value,
	// warnings will be produced when the vstring alue contains substitutions
	// as there is no way to know the final value during the validation phase.
	// 0 means that there is no maximum length constraint.
	// Allowed values will take precedence over this constraint for values of type "string".
	MaxLength int
	// Pattern holds a regular expression pattern that can be used to validate
	// a string value in a resource spec that uses this schema.
	// This is only used for "string" types.
	// The pattern must be a valid Go regular expression, see: https://pkg.go.dev/regexp/syntax.
	// Allowed values will take precedence over this constraint.
	Pattern string
	// ValidateFunc is a custom validation function that can be used to validate
	// a resource spec value that uses this schema.
	// This function will be called during the validation phase of a resource
	// and can be used to perform additional validation that is not covered
	// by the schema definition.
	// This can also be useful for targeted conditional validation based on other
	// known values in the resource as defined in the source blueprint document.
	// The function should return a list of diagnostics that will be used to
	// report validation errors and warnings, validation will fail if at least one
	// diagnostic is of level `core.DiagnosticLevelError`.
	//
	// All first-class validation properties such as `AllowedValues`, `Minimum`, `Maximum`,
	// `MinLength`, `MaxLength` and `Pattern` will be applied before the custom validation function
	// is called, so the custom validation function should not be used to validate
	// and will only be called if a non-nil value is provided for the value and the value
	// is known at the validation stage.
	// This will not be called for computed values or fields that contain ${..} substitutions
	// as the value is not known at the initial validation stage.
	ValidateFunc func(
		path string,
		value *core.MappingNode,
		resource *schema.Resource,
	) []*core.Diagnostic
	// Default holds the default value for a resource spec schema,
	// this will be populated in the `Resource.Spec.*` mapping node
	// if the resource spec is missing a value
	// for a specific attribute or item in the spec.
	// The default value will not be used if the attribute value in a given resource spec is nil
	// and the schema is nullable, a nil pointer should not be used
	// for an empty value, pointers should be set when you want to explicitly
	// set a value to nil.
	// The default value will not be used for computed values in a resource spec.
	Default *core.MappingNode
	// Examples holds a list of examples for the resource definition element.
	// Examples are useful for documentation and tooling.
	Examples []*core.MappingNode
	// Computed specifies whether the value is computed by the provider
	// and should not be set by the user.
	// Computed values are expected to be populated by resource implementations
	// in a provider in the deployment process.
	Computed bool
	// MustRecreate specifies whether the resource must be recreated
	// if a change to the field is detected in the resource state.
	// This is only used for user-provided values, it will be ignored
	// for computed values.
	MustRecreate bool
}

type ResourceDefinitionsSchemaType string

type ResourceDeployError struct {
	FailureReasons []string
	ChildError     error
}

type ResourceDeployInput struct {
	InstanceID string
	// Additional user-defined blueprint instance name
	// that can be used in ID/unique name generation and for debugging.
	InstanceName    string
	ResourceID      string
	Changes         *Changes
	ProviderContext Context
}

type ResourceDeployOutput struct {
	// ComputedFieldValues holds a mapping of computed field paths
	// to their values.
	// Examples of computed fields are the ARN of an AWS Lambda function
	// or the ID of a Google Cloud Storage bucket.
	// Some examples of valid computed field paths are:
	// - `spec.arn`
	// - `spec.id`
	// - `spec.arns[0]`
	// - `spec.identifiers["id.v1"]`
	// - `spec["identifiers.1"].arn`
	//
	// The computed fields will be injected into the final resource state that
	// will be persisted as a part of the blueprint instance state.
	ComputedFieldValues map[string]*core.MappingNode
}

type ResourceDeployService interface {
	// Deploy deals with the deployment of a resource of a given type.
	// Callers can specify whether or not to wait for the resource to stabilise
	// before returning.
	Deploy(
		ctx context.Context,
		resourceType string,
		input *ResourceDeployServiceInput,
	) (*ResourceDeployOutput, error)
	// Destroy deals with the destruction of a resource of a given type.
	Destroy(
		ctx context.Context,
		resourceType string,
		input *ResourceDestroyInput,
	) error
}

type ResourceDeployServiceInput struct {
	// DeployInput is the input for the resource deployment that is passed into the `Deploy`
	// method of a `provider.Resource` implementation.
	DeployInput *ResourceDeployInput
	// WaitUntilStable specifies whether or not to
	// wait for the resource to stabilise before returning.
	WaitUntilStable bool
}

type ResourceDestroyError struct {
	FailureReasons []string
	ChildError     error
}

type ResourceDestroyInput struct {
	InstanceID string
	// Additional user-defined blueprint instance name
	// that can be used in ID/unique name generation and for debugging.
	InstanceName    string
	ResourceID      string
	ResourceState   *state.ResourceState
	ProviderContext Context
}

type ResourceGetExamplesInput struct {
	ProviderContext Context
}

type ResourceGetExamplesOutput struct {
	MarkdownExamples  []string
	PlainTextExamples []string
}

type ResourceGetExternalStateInput struct {
	InstanceID string
	// Additional user-defined blueprint instance name
	// that can be used in ID/unique name generation and for debugging.
	InstanceName            string
	ResourceID              string
	CurrentResourceSpec     *core.MappingNode
	CurrentResourceMetadata *state.ResourceMetadataState
	ProviderContext         Context
}

type ResourceGetExternalStateOutput struct {
	ResourceSpecState *core.MappingNode
}

type ResourceGetSpecDefinitionInput struct {
	ProviderContext Context
}

type ResourceGetSpecDefinitionOutput struct {
	SpecDefinition *ResourceSpecDefinition
}

type ResourceGetTypeDescriptionInput struct {
	ProviderContext Context
}

type ResourceGetTypeDescriptionOutput struct {
	MarkdownDescription  string
	PlainTextDescription string
	// A short summary of the resource type that can be formatted
	// in markdown, this is useful for listing resource types in documentation.
	MarkdownSummary string
	// A short summary of the resource type in plain text,
	// this is useful for listing resource types in documentation.
	PlainTextSummary string
}

type ResourceGetTypeInput struct {
	ProviderContext Context
}

type ResourceGetTypeOutput struct {
	Type string
	// A human-readable label for the resource type.
	Label string
}

type ResourceHasStabilisedInput struct {
	InstanceID string
	// Additional user-defined blueprint instance name
	// that can be used in ID/unique name generation and for debugging.
	InstanceName     string
	ResourceID       string
	ResourceSpec     *core.MappingNode
	ResourceMetadata *state.ResourceMetadataState
	ProviderContext  Context
}

type ResourceHasStabilisedOutput struct {
	Stabilised bool
}

type ResourceInfo struct {
	// ResourceID holds the ID of a resource when in the context
	// of a blueprint instance when deploying or staging changes.
	// Sometimes staging changes is independent of an instance and is used to compare
	// two versions of a blueprint in which
	// case the resource ID will be empty.
	ResourceID string `json:"resourceId"`
	// ResourceName holds the name of the resource in the blueprint spec.
	// This is useful for new resources that do not have any current resource state.
	ResourceName string `json:"resourceName"`
	// InstanceID holds the ID of the blueprint instance
	// that the current resource belongs to.
	// This could be empty if the resource is being staged
	// for an initial deployment.
	InstanceID string `json:"instanceId"`
	// CurrentResourceState holds the current state of the resource
	// for which changes are being staged.
	// The ResourceInfo struct is passed into resource implementation plugins
	// for deployment.
	// A resource implementation should be guarded from the details of where
	// the state is stored and how it is retrieved,
	// the state should be provided to resource plugins by the blueprint
	// engine.
	// If this is a nil pointer, it means that the resource is new and does not have
	// a current state.
	CurrentResourceState *state.ResourceState `json:"currentResourceState"`
	// ResourceWithResolvedSubs holds a version of a resource for which all ${..}
	// substitutions have been applied.
	ResourceWithResolvedSubs *ResolvedResource `json:"resourceWithResolvedSubs"`
}

type ResourceIsCommonTerminalInput struct {
	ProviderContext Context
}

type ResourceIsCommonTerminalOutput struct {
	IsCommonTerminal bool
}

type ResourceSpecDefinition struct {
	// Schema holds the schema for the resource
	// specification.
	Schema *ResourceDefinitionsSchema
	// IDField holds the name of the field in the resource spec
	// that holds the ID of the resource.
	// This is used to resolve references to a resource in a blueprint
	// where only the name of the resource is specified.
	// For example, references such as `resources.processOrderFunction` or `processOrderFunction`
	// should resolve to the ID of the resource in the blueprint.
	// The ID field must be a top-level property of the resource spec schema.
	IDField string
}

type ResourceStabilisedDependenciesInput struct {
	ProviderContext Context
}

type ResourceStabilisedDependenciesOutput struct {
	StabilisedDependencies []string
}

type ResourceValidateInput struct {
	SchemaResource  *schema.Resource
	ProviderContext Context
}

type ResourceValidateOutput struct {
	Diagnostics []*core.Diagnostic
}

type RetryContext struct {
	Attempt            int
	ExceededMaxRetries bool
	Policy             *RetryPolicy
	AttemptDurations   []float64
	AttemptStartTime   time.Time
}

type RetryPolicy struct {
	// MaxRetries is the maximum number of retries that should be attempted
	// for a resource, link or data source operation.
	// If MaxRetries is 0, no retries should be attempted.
	MaxRetries int `json:"maxRetries"`
	// FirstRetryDelay is the delay in seconds that should be used before the first retry
	// attempt.
	// Fractional seconds are supported.
	FirstRetryDelay float64 `json:"firstRetryDelay"`
	// MaxDelay represents the maximum interval in seconds to wait between retries.
	// If -1 is provided, no maximum delay is enforced.
	// Fractional seconds are supported.
	MaxDelay float64 `json:"maxDelay"`
	// BackoffFactor is the factor that should be used to calculate the backoff
	// time between retries.
	// This AWS blog post from 2015 provides a good insight into how exponential backoff works:
	// https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
	BackoffFactor float64 `json:"backoffFactor"`
	// Jitter is a boolean value that determines whether to apply jitter to the retry interval.
	// This AWS blog post from 2015 provides a good insight into how jitter works:
	// https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
	Jitter bool `json:"jitter"`
}

type RetryableError struct {
	// The underlying error for the action that can be retried.
	ChildError error
}