spec

type AnswerID struct {
	AskRef string `json:"askRef"`
	Name   string `json:"name"`
}

type AnswerMappingTypeResolver struct {
	AnswerTypeResolver
}

type AnswerTypeResolver interface {
	ResolveAnswer(ctx context.Context, askRef, name string) (any, error)
}

type ConnectionID struct {
	Type string `json:"type"`
	Name string `json:"name"`
}

type ConnectionMappingTypeResolver struct {
	ConnectionTypeResolver
}

type ConnectionTemplateEnvironment struct {
	ConnectionTypeResolver
}

type ConnectionTypeResolver interface {
	ResolveAllConnections(ctx context.Context) (map[string]map[string]any, error)
	ResolveTypeOfConnections(ctx context.Context, connectionType string) (map[string]any, error)
	ResolveConnection(ctx context.Context, connectionType, name string) (any, error)
}

type DataID struct {
	Name string `json:"name"`
}

type DataMappingTypeResolver map[string]DataTypeResolver

type DataQueryError struct {
	Query string
	Cause error
}

type DataResolverNotFoundError struct {
	Name string
}

type DataTemplateEnvironment struct {
	DataTypeResolver
	Name string
}

type DataTypeResolver interface {
	ResolveData(ctx context.Context) (any, error)
}

type FieldNotFoundError struct {
	Name string
}

type JSONTree struct {
	Tree any
}

type MemoryAnswerKey struct {
	AskRef string
	Name   string
}

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

type MemoryConnectionKey struct {
	Type string
	Name string
}

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

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

type MemoryOutputKey struct {
	From string
	Name string
}

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

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

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

type MemoryStatusKey struct {
	Action   string
	Property string
}

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

type Option interface {
	ApplyToOptions(target *Options)
}

type Options struct {
	DataTypeResolvers      map[string]DataTypeResolver
	SecretTypeResolver     SecretTypeResolver
	ConnectionTypeResolver ConnectionTypeResolver
	OutputTypeResolver     OutputTypeResolver
	ParameterTypeResolver  ParameterTypeResolver
	AnswerTypeResolver     AnswerTypeResolver
	StatusTypeResolver     StatusTypeResolver
}

type OutputID struct {
	From string `json:"from"`
	Name string `json:"name"`
}

type OutputMappingTypeResolver struct {
	OutputTypeResolver
}

type OutputTemplateEnvironment struct {
	OutputTypeResolver
}

type OutputTypeResolver interface {
	ResolveAllOutputs(ctx context.Context) (map[string]map[string]any, error)
	ResolveStepOutputs(ctx context.Context, from string) (map[string]any, error)
	ResolveOutput(ctx context.Context, from, name string) (any, error)
}

type ParameterID struct {
	Name string `json:"name"`
}

type ParameterMappingTypeResolver struct {
	ParameterTypeResolver
}

type ParameterTemplateEnvironment struct {
	ParameterTypeResolver
}

type ParameterTypeResolver interface {
	ResolveAllParameters(ctx context.Context) (map[string]any, error)
	ResolveParameter(ctx context.Context, name string) (any, error)
}

type References struct {
	Data        *ref.Log[DataID]
	Secrets     *ref.Log[SecretID]
	Connections *ref.Log[ConnectionID]
	Outputs     *ref.Log[OutputID]
	Parameters  *ref.Log[ParameterID]
	Answers     *ref.Log[AnswerID]
	Statuses    *ref.Log[StatusID]
}

type SecretID struct {
	Name string `json:"name"`
}

type SecretMappingTypeResolver struct {
	SecretTypeResolver
}

type SecretTemplateEnvironment struct {
	SecretTypeResolver
}

type SecretTypeResolver interface {
	ResolveAllSecrets(ctx context.Context) (map[string]string, error)
	ResolveSecret(ctx context.Context, name string) (string, error)
}

type StatusID struct {
	Action   string `json:"action"`
	Property string `json:"property"`
}

type StatusTemplateEnvironment struct {
	StatusTypeResolver
}

type StatusTypeResolver interface {
	ResolveStatus(ctx context.Context, name, property string) (bool, error)
}

type UnresolvableError struct {
	Causes []error
}

type WithAnswerTypeResolver struct{ AnswerTypeResolver }

type WithConnectionTypeResolver struct{ ConnectionTypeResolver }

type WithDataTypeResolver struct {
	Name             string
	Default          bool
	DataTypeResolver DataTypeResolver
}

type WithOutputTypeResolver struct{ OutputTypeResolver }

type WithParameterTypeResolver struct{ ParameterTypeResolver }

type WithSecretTypeResolver struct{ SecretTypeResolver }

type WithStatusTypeResolver struct{ StatusTypeResolver }

type YAMLAnswerTransformer struct{}

type YAMLBinaryToEncodingTransformer struct{}

type YAMLConnectionTransformer struct{}

type YAMLDataTransformer struct{}

type YAMLInvocationTransformer struct{}

type YAMLOutputTransformer struct{}

type YAMLParameterTransformer struct{}

type YAMLSecretTransformer struct{}

type YAMLTransformer interface {
	Transform(node *yaml.Node) (bool, error)
}

type YAMLTree struct {
	Tree any
}

type YAMLUnknownTagTransformer struct{}