plugin

type CtyDecoder interface {
	DecodeCty(xpresource.Managed, cty.Value, *providers.Schema) (xpresource.Managed, error)
}

type CtyEncoder interface {
	EncodeCty(xpresource.Managed, *providers.Schema) (cty.Value, error)
}

type Implementation struct {
	// GVK is used to index other elements of the Entry by GVK
	GVK k8schema.GroupVersionKind
	// TerraformResourceName is needed to map the crossplane type
	// to the Terraform type name. This is needed to find the schema
	// for the type and to identify the type in API calls.
	TerraformResourceName string
	// SchemeBuilder is used to register the controller for this type with the
	// controller runtime. StartTerraformManager (in pkg/controller) iterates
	// through all the registration entries and performs the bindings.
	SchemeBuilder *scheme.Builder
	// ReconcilerConfigurer is the function responsible for calling
	// managed.NewReconciler to bind the reconciler to the managed resource
	// type. It is also invoked in StartTerraformManager.
	ReconcilerConfigurer ReconcilerConfigurer
	// ResourceMerger can update the local kubernetes object with attributes
	// from the cloud provider, late-initializing Spec fields, copying over Status
	// fields and annotations.
	ResourceMerger ResourceMerger
	// CtyEncoder produces the cty.Value (cty-encoded resource for
	// terraform) for a resource.Managed, given the corresponding schema
	// object. Note that we do not try to compile schemas in to the generated
	// code, they are always obtained from the terraform process itself.
	CtyEncoder CtyEncoder
	// CtyDecoder is the complement to EncodeCtyCallback. In addition
	// to the schema and cty.Value, it also requires a resource.Managed, using
	// the deepcopied value from this resource as the base structure (and
	// providing values for .Spec fields and k8s metadata)
	CtyDecoder CtyDecoder
	// ResourceYAMLMarshaller is the complement to UnmarshalResourceCallback, taking
	// a resource.Managed and producing the []byte representation.
	ResourceYAMLMarshaller ResourceYAMLMarshaller
	// ResourceYAMLUnmarshaller is only used for prototyping atm -- it's a
	// function that can parse the []byte representation of a managed resource
	// to a resource.Managed
	ResourceYAMLUnmarshaller ResourceYAMLUnmarshaller
}

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

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

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

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

type MergeDescription struct {
	LateInitializedSpec bool
	StatusUpdated       bool
	AnnotationsUpdated  bool
	NeedsProviderUpdate bool
	AnyFieldUpdated     bool
}

type ProviderInit struct {
	GVK           k8schema.GroupVersionKind
	SchemeBuilder *scheme.Builder
	Initializer   client.Initializer
}

type ReconcilerConfigurer interface {
	ConfigureReconciler(ctrl.Manager, logging.Logger, *Index, *client.ProviderPool) error
}

type ResourceMerger interface {
	MergeResources(xpresource.Managed, xpresource.Managed) MergeDescription
}

type ResourceYAMLMarshaller interface {
	MarshalResourceYAML(xpresource.Managed) ([]byte, error)
}

type ResourceYAMLUnmarshaller interface {
	UnmarshalResourceYAML([]byte) (xpresource.Managed, error)
}