extensions

type ARMResourceModifier interface {
	// ModifyARMResource takes a genruntime.ARMResource and returns an updated genruntime.ARMResource. The updated resource
	// is then serialized and sent to ARM in the body of a PUT request.
	// ctx is the current operation context.
	// armClient allows making additional ARM API calls if needed to determine modifications.
	// armObj is the ARM resource representation about to be sent.
	// obj is the Kubernetes resource being reconciled.
	// kubeClient allows access to the Kubernetes cluster.
	// resolver helps resolve resource references.
	// log is a logger for the current operation.
	ModifyARMResource(
		ctx context.Context,
		armClient *genericarmclient.GenericClient,
		armObj genruntime.ARMResource,
		obj genruntime.ARMMetaObject,
		kubeClient kubeclient.Client,
		resolver *resolver.Resolver,
		log logr.Logger,
	) (genruntime.ARMResource, error)
}

type ARMResourceModifierFunc = func(ctx context.Context, obj genruntime.ARMMetaObject, armObj genruntime.ARMResource) (genruntime.ARMResource, error)

type ClaimFunc = func(ctx context.Context, log logr.Logger, obj genruntime.ARMOwnedMetaObject) error

type Claimer interface {
	// Claim claims the resource by establishing its Azure Resource Manager ID.
	// ctx is the current operation context.
	// log is a logger for the current operation.
	// obj is the Kubernetes resource being claimed.
	// next is the default claim implementation - call this to use standard claiming logic.
	Claim(ctx context.Context, log logr.Logger, obj genruntime.ARMOwnedMetaObject, next ClaimFunc) error
}

type DeleteFunc = func(
	ctx context.Context,
	log logr.Logger,
	resolver *resolver.Resolver,
	armClient *genericarmclient.GenericClient,
	obj genruntime.ARMMetaObject) (ctrl.Result, error)

type Deleter interface {
	// Delete deletes the resource from Azure, with the ability to perform custom logic before, during, or after deletion.
	// ctx is the current operation context.
	// log is a logger for the current operation.
	// resolver helps resolve resource references.
	// armClient allows making ARM API calls.
	// obj is the Kubernetes resource being deleted.
	// next is the default deletion implementation - call this to perform standard ARM DELETE.
	// Returns a reconciliation result (e.g., requeue timing) and an error if deletion fails.
	Delete(
		ctx context.Context,
		log logr.Logger,
		resolver *resolver.Resolver,
		armClient *genericarmclient.GenericClient,
		obj genruntime.ARMMetaObject,
		next DeleteFunc) (ctrl.Result, error)
}

type ErrorClassifier interface {
	// ClassifyError evaluates the provided error, returning details including whether it is fatal or can be retried.
	// cloudError is the error returned from ARM.
	// apiVersion is the ARM API version used for the request.
	// log is a logger that can be used for telemetry.
	// next is the default classification implementation to call.
	// Returns CloudErrorDetails with classification and an error if classification itself fails.
	ClassifyError(
		cloudError *genericarmclient.CloudError,
		apiVersion string,
		log logr.Logger,
		next ErrorClassifierFunc) (core.CloudErrorDetails, error)
}

type ErrorClassifierFunc func(cloudError *genericarmclient.CloudError) (core.CloudErrorDetails, error)

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

type Importer interface {
	// Import allows interception of the import process to skip or modify resources being imported.
	// ctx is the current asynchronous context
	// rsrc is the resource being imported.
	// owner is an optional owner for the resource.
	// next is a function to call to do the actual import.
	// Returns an ImportResult indicating success or skip with a reason, and an error if import fails.
	Import(
		ctx context.Context,
		rsrc genruntime.ImportableResource,
		owner *genruntime.ResourceReference,
		next ImporterFunc,
	) (ImportResult, error)
}

type ImporterFunc func(
	ctx context.Context,
	resource genruntime.ImportableResource,
	owner *genruntime.ResourceReference,
) (ImportResult, error)

type KubernetesSecretExportFunc = func(obj genruntime.MetaObject, additionalSecrets set.Set[string]) (*genruntime.KubernetesSecretExportResult, error)

type PostReconcileCheckFunc func(
	ctx context.Context,
	obj genruntime.MetaObject,
	owner genruntime.MetaObject,
	resourceResolver *resolver.Resolver,
	armClient *genericarmclient.GenericClient,
	log logr.Logger,
) (PostReconcileCheckResult, error)

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

type PostReconciliationChecker interface {
	// PostReconcileCheck does a post-reconcile check to see if the resource is in a state to set 'Ready' condition.
	// ARM resources should implement this if they need to defer the Ready condition until later.
	// Returns PostReconcileCheckResultSuccess if the reconciliation is successful.
	// Returns PostReconcileCheckResultFailure and a human-readable reason if the reconciliation should put a condition on resource.
	// ctx is the current operation context.
	// obj is the resource that was reconciled. The resource's status will be freshly updated.
	// owner is the parent resource of obj. This can be nil in some cases like `ResourceGroups` and `Alias`.
	// resourceResolver helps resolve resource references.
	// armClient allows access to ARM for any required queries.
	// log is the logger for the current operation.
	// next is the default check implementation (usually returns success).
	PostReconcileCheck(
		ctx context.Context,
		obj genruntime.MetaObject,
		owner genruntime.MetaObject,
		resourceResolver *resolver.Resolver,
		armClient *genericarmclient.GenericClient,
		log logr.Logger,
		next PostReconcileCheckFunc,
	) (PostReconcileCheckResult, error)
}

type PreReconcileCheckFunc func(
	ctx context.Context,
	obj genruntime.MetaObject,
	resourceResolver *resolver.Resolver,
	armClient *genericarmclient.GenericClient,
	log logr.Logger,
) (PreReconcileCheckResult, error)

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

type PreReconcileOwnerCheckFunc func(
	ctx context.Context,
	owner genruntime.MetaObject,
	resourceResolver *resolver.Resolver,
	armClient *genericarmclient.GenericClient,
	log logr.Logger,
) (PreReconcileCheckResult, error)

type PreReconciliationChecker interface {
	// PreReconcileCheck does a pre-reconcile check to see if the resource is in a state that can be reconciled.
	// ARM resources should implement this to avoid reconciliation attempts that cannot possibly succeed.
	// Returns ProceedWithReconcile if the reconciliation should go ahead.
	// Returns BlockReconcile and a human-readable reason if the reconciliation should be skipped.
	// ctx is the current operation context.
	// obj is the resource about to be reconciled. The resource's status will be freshly updated.
	// resourceResolver helps resolve resource references.
	// armClient allows access to ARM for any required queries.
	// log is the logger for the current operation.
	// next is the next (nested) implementation to call.
	PreReconcileCheck(
		ctx context.Context,
		obj genruntime.MetaObject,
		resourceResolver *resolver.Resolver,
		armClient *genericarmclient.GenericClient,
		log logr.Logger,
		next PreReconcileCheckFunc,
	) (PreReconcileCheckResult, error)
}

type PreReconciliationOwnerChecker interface {
	// PreReconcileOwnerCheck does a pre-reconcile check to see if the owner of a resource is in a state that permits
	// the resource to be reconciled. For a limited number of resources, the state of their owner can block all access
	// to the resource, including GETs. One example is a Kusto Cluster, where you can't even GET the database if the
	// cluster is powered off.
	// Prefer to implement PreReconciliationChecker unless you specifically need to avoid GETs on the resource itself.
	// ARM resources should implement this to avoid reconciliation attempts that cannot possibly succeed.
	// Returns ProceedWithReconcile if the reconciliation should go ahead.
	// Returns BlockReconcile and a human-readable reason if the reconciliation should be skipped.
	// ctx is the current operation context.
	// owner is the owner of the resource about to be reconciled. The owner's status will be freshly updated. May be nil
	// if the resource has no owner, or if it has been referenced via ARMID directly.
	// resourceResolver helps resolve resource references.
	// armClient allows access to ARM for any required queries.
	// log is the logger for the current operation.
	// next is the next (nested) implementation to call.
	PreReconcileOwnerCheck(
		ctx context.Context,
		owner genruntime.MetaObject,
		resourceResolver *resolver.Resolver,
		armClient *genericarmclient.GenericClient,
		log logr.Logger,
		next PreReconcileOwnerCheckFunc,
	) (PreReconcileCheckResult, error)
}

type SuccessFunc = func(obj genruntime.ARMMetaObject) error

type SuccessfulCreationHandler interface {
	// Success performs custom logic after the resource is successfully created in Azure for the first time.
	// obj is the resource that was just created, with populated status including the Azure resource ID.
	// Returns an error if the success handling fails, which will prevent the Ready condition from being set.
	Success(obj genruntime.ARMMetaObject) error
}