managed

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

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

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

type AdditionalDetails map[string]string

type ChangeLogger interface {
	Log(ctx context.Context, managed resource.Managed, opType v1alpha1.OperationType, changeErr error, ad AdditionalDetails) error
}

type ConnectionDetails map[string][]byte

type ConnectionDetailsFetcher interface {
	FetchConnection(ctx context.Context, so resource.ConnectionSecretOwner) (ConnectionDetails, error)
}

type ConnectionPublisher interface {
	// PublishConnection details for the supplied Managed resource. Publishing
	// must be additive; i.e. if details (a, b, c) are published, subsequently
	// publicing details (b, c, d) should update (b, c) but not remove a.
	PublishConnection(ctx context.Context, so resource.ConnectionSecretOwner, c ConnectionDetails) (published bool, err error)

	// UnpublishConnection details for the supplied Managed resource.
	UnpublishConnection(ctx context.Context, so resource.ConnectionSecretOwner, c ConnectionDetails) error
}

type ConnectionPublisherFns struct {
	PublishConnectionFn   func(ctx context.Context, o resource.ConnectionSecretOwner, c ConnectionDetails) (bool, error)
	UnpublishConnectionFn func(ctx context.Context, o resource.ConnectionSecretOwner, c ConnectionDetails) error
}

type CriticalAnnotationUpdateFn func(ctx context.Context, o client.Object) error

type CriticalAnnotationUpdater interface {
	UpdateCriticalAnnotations(ctx context.Context, o client.Object) error
}

type ExternalClient = TypedExternalClient[resource.Managed]

type ExternalClientFns = TypedExternalClientFns[resource.Managed]

type ExternalConnectDisconnecterFns = ExternalConnectDisconnectorFns

type ExternalConnectDisconnector = TypedExternalConnectDisconnector[resource.Managed]

type ExternalConnectDisconnectorFns = TypedExternalConnectDisconnectorFns[resource.Managed]

type ExternalConnecter = ExternalConnector

type ExternalConnector = TypedExternalConnector[resource.Managed]

type ExternalConnectorFn = TypedExternalConnectorFn[resource.Managed]

type ExternalCreation struct {
	// ConnectionDetails required to connect to this resource. These details
	// are a set that is collated throughout the managed resource's lifecycle -
	// i.e. returning new connection details will have no affect on old details
	// unless an existing key is overwritten. Crossplane may publish these
	// credentials to a store (e.g. a Secret).
	ConnectionDetails ConnectionDetails

	// AdditionalDetails represent any additional details the external client
	// wants to return about the creation operation that was performed.
	AdditionalDetails AdditionalDetails
}

type ExternalDelete struct {
	// AdditionalDetails represent any additional details the external client
	// wants to return about the delete operation that was performed.
	AdditionalDetails AdditionalDetails
}

type ExternalDisconnecterFn = ExternalDisconnectorFn

type ExternalDisconnectorFn func(ctx context.Context) error

type ExternalObservation struct {
	// ResourceExists must be true if a corresponding external resource exists
	// for the managed resource. Typically this is proven by the presence of an
	// external resource of the expected kind whose unique identifier matches
	// the managed resource's external name. Crossplane uses this information to
	// determine whether it needs to create or delete the external resource.
	ResourceExists bool

	// ResourceUpToDate should be true if the corresponding external resource
	// appears to be up-to-date - i.e. updating the external resource to match
	// the desired state of the managed resource would be a no-op. Keep in mind
	// that often only a subset of external resource fields can be updated.
	// Crossplane uses this information to determine whether it needs to update
	// the external resource.
	ResourceUpToDate bool

	// ResourceLateInitialized should be true if the managed resource's spec was
	// updated during its observation. A Crossplane provider may update a
	// managed resource's spec fields after it is created or updated, as long as
	// the updates are limited to setting previously unset fields, and adding
	// keys to maps. Crossplane uses this information to determine whether
	// changes to the spec were made during observation that must be persisted.
	// Note that changes to the spec will be persisted before changes to the
	// status, and that pending changes to the status may be lost when the spec
	// is persisted. Status changes will be persisted by the first subsequent
	// observation that _does not_ late initialize the managed resource, so it
	// is important that Observe implementations do not late initialize the
	// resource every time they are called.
	ResourceLateInitialized bool

	// ConnectionDetails required to connect to this resource. These details
	// are a set that is collated throughout the managed resource's lifecycle -
	// i.e. returning new connection details will have no affect on old details
	// unless an existing key is overwritten. Crossplane may publish these
	// credentials to a store (e.g. a Secret).
	ConnectionDetails ConnectionDetails

	// Diff is a Debug level message that is sent to the reconciler when
	// there is a change in the observed Managed Resource. It is useful for
	// finding where the observed diverges from the desired state.
	// The string should be a cmp.Diff that details the difference.
	Diff string
}

type ExternalUpdate struct {
	// ConnectionDetails required to connect to this resource. These details
	// are a set that is collated throughout the managed resource's lifecycle -
	// i.e. returning new connection details will have no affect on old details
	// unless an existing key is overwritten. Crossplane may publish these
	// credentials to a store (e.g. a Secret).
	ConnectionDetails ConnectionDetails

	// AdditionalDetails represent any additional details the external client
	// wants to return about the update operation that was performed.
	AdditionalDetails AdditionalDetails
}

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

type GRPCChangeLoggerOption func(*GRPCChangeLogger)

type Initializer interface {
	Initialize(ctx context.Context, mg resource.Managed) error
}

type InitializerChain []Initializer

type InitializerFn func(ctx context.Context, mg resource.Managed) error

type LegacyManagementPoliciesResolver struct {
	*ManagementPoliciesResolver
	// contains filtered or unexported fields
}

type LocalConnectionPublisher interface {
	// PublishConnection details for the supplied Managed resource. Publishing
	// must be additive; i.e. if details (a, b, c) are published, subsequently
	// publicing details (b, c, d) should update (b, c) but not remove a.
	PublishConnection(ctx context.Context, lso resource.LocalConnectionSecretOwner, c ConnectionDetails) (published bool, err error)

	// UnpublishConnection details for the supplied Managed resource.
	UnpublishConnection(ctx context.Context, lso resource.LocalConnectionSecretOwner, c ConnectionDetails) error
}

type LocalConnectionPublisherFns struct {
	PublishConnectionFn   func(ctx context.Context, o resource.LocalConnectionSecretOwner, c ConnectionDetails) (bool, error)
	UnpublishConnectionFn func(ctx context.Context, o resource.LocalConnectionSecretOwner, c ConnectionDetails) error
}

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

type ManagementPoliciesChecker interface {
	// Validate validates the management policies.
	Validate() error
	// IsPaused returns true if the resource is paused based
	// on the management policy.
	IsPaused() bool

	// ShouldOnlyObserve returns true if only the Observe action is allowed.
	ShouldOnlyObserve() bool
	// ShouldCreate returns true if the Create action is allowed.
	ShouldCreate() bool
	// ShouldLateInitialize returns true if the LateInitialize action is
	// allowed.
	ShouldLateInitialize() bool
	// ShouldUpdate returns true if the Update action is allowed.
	ShouldUpdate() bool
	// ShouldDelete returns true if the Delete action is allowed.
	ShouldDelete() bool
}

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

type ManagementPoliciesResolverOption func(*ManagementPoliciesResolver)

type MetricRecorder interface {
	Describe(ch chan<- *prometheus.Desc)
	Collect(ch chan<- prometheus.Metric)
	// contains filtered or unexported methods
}

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

type NopClient struct{}

type NopConnecter = NopConnector

type NopConnector struct{}

type NopDisconnecter = NopDisconnector

type NopDisconnector = TypedNopDisconnector[resource.Managed]

type NopMetricRecorder struct{}

type PollIntervalHook func(managed resource.Managed, pollInterval time.Duration) time.Duration

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

type ReconcilerOption func(*Reconciler)

type ReferenceResolver interface {
	// ResolveReferences resolves all fields in the supplied managed resource
	// that are references to other managed resources by updating corresponding
	// fields, for example setting spec.network to the Network resource
	// specified by spec.networkRef.name.
	ResolveReferences(ctx context.Context, mg resource.Managed) error
}

type ReferenceResolverFn func(context.Context, resource.Managed) error

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

type TypedExternalClient[managedType resource.Managed] interface {
	// Observe the external resource the supplied Managed resource
	// represents, if any. Observe implementations must not modify the
	// external resource, but may update the supplied Managed resource to
	// reflect the state of the external resource. Status modifications are
	// automatically persisted unless ResourceLateInitialized is true - see
	// ResourceLateInitialized for more detail.
	Observe(ctx context.Context, mg managedType) (ExternalObservation, error)

	// Create an external resource per the specifications of the supplied
	// Managed resource. Called when Observe reports that the associated
	// external resource does not exist. Create implementations may update
	// managed resource annotations, and those updates will be persisted.
	// All other updates will be discarded.
	Create(ctx context.Context, mg managedType) (ExternalCreation, error)

	// Update the external resource represented by the supplied Managed
	// resource, if necessary. Called unless Observe reports that the
	// associated external resource is up to date.
	Update(ctx context.Context, mg managedType) (ExternalUpdate, error)

	// Delete the external resource upon deletion of its associated Managed
	// resource. Called when the managed resource has been deleted.
	Delete(ctx context.Context, mg managedType) (ExternalDelete, error)

	// Disconnect from the provider and close the ExternalClient.
	// Called at the end of reconcile loop. An ExternalClient not requiring
	// to explicitly disconnect to cleanup it resources, can provide a no-op
	// implementation which just return nil.
	Disconnect(ctx context.Context) error
}

type TypedExternalClientFns[managed resource.Managed] struct {
	ObserveFn    func(ctx context.Context, mg managed) (ExternalObservation, error)
	CreateFn     func(ctx context.Context, mg managed) (ExternalCreation, error)
	UpdateFn     func(ctx context.Context, mg managed) (ExternalUpdate, error)
	DeleteFn     func(ctx context.Context, mg managed) (ExternalDelete, error)
	DisconnectFn func(ctx context.Context) error
}

type TypedExternalConnectDisconnector[managed resource.Managed] interface {
	TypedExternalConnector[managed]
	ExternalDisconnector
}

type TypedExternalConnectDisconnectorFns[managed resource.Managed] struct {
	ConnectFn    func(ctx context.Context, mg managed) (TypedExternalClient[managed], error)
	DisconnectFn func(ctx context.Context) error
}

type TypedExternalConnecter[managed resource.Managed] interface {
	TypedExternalConnector[managed]
}

type TypedExternalConnector[managed resource.Managed] interface {
	// Connect to the provider specified by the supplied managed resource and
	// produce an ExternalClient.
	Connect(ctx context.Context, mg managed) (TypedExternalClient[managed], error)
}

type TypedExternalConnectorFn[managed resource.Managed] func(ctx context.Context, mg managed) (TypedExternalClient[managed], error)

type TypedNopDisconnector[managed resource.Managed] struct {
	// contains filtered or unexported fields
}