zip

type AddToScheme func(*runtime.Scheme) error

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

type ClientOption func(*ClientConfig) error

type Method[In, Out ReferenceObject] func(context.Context, In) (Out, error)

type MethodClient[In, Out ReferenceObject] struct {
	// contains filtered or unexported fields
}

type MethodStrategy[In, Out ReferenceObject] interface {
	// Do performs the request by invoking the provided generic Method.
	Do(context.Context, In) (Out, error)
}

type Object[Spec, Status any] struct {
	metav1.TypeMeta `json:",inline"`

	// Standard object's metadata.
	metav1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`

	// Specification of the desired behavior of the Object.
	Spec Spec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`

	// Most recently observed status of the Object.
	Status Status `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}

type ObjectList[Spec, Status any] struct {
	metav1.TypeMeta `json:",inline"`

	// Standard object's metadata.
	metav1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`

	// Items contains the list of machines.
	Items []Object[Spec, Status] `json:"items" protobuf:"bytes,2,rep,name=items"`
}

type OnAfter func(context.Context, ReferenceObject, ReferenceObject) (any, error)

type OnBefore func(context.Context, ReferenceObject) (any, error)

type Referencable interface {
	Reference() (string, error)
}

type ReferenceObject interface {
	Referencable
	runtime.Object
}

type Store interface {
	// Returns Versioner associated with this interface.
	Versioner() storage.Versioner

	// Create adds a new object at a key unless it already exists. 'ttl' is
	// time-to-live in seconds (0 means forever). If no error is returned and out
	// is not nil, out will be set to the read value from database.
	Create(ctx context.Context, key string, obj, out runtime.Object, ttl uint64) error

	// Delete removes the specified key and returns the value that existed at that spot.
	// If key didn't exist, it will return NotFound storage error.
	// If 'cachedExistingObject' is non-nil, it can be used as a suggestion about the
	// current version of the object to avoid read operation from storage to get it.
	// However, the implementations have to retry in case suggestion is stale.
	Delete(
		ctx context.Context, key string, out runtime.Object, preconditions *storage.Preconditions,
		validateDeletion storage.ValidateObjectFunc, cachedExistingObject runtime.Object,
		opts storage.DeleteOptions) error

	// Watch begins watching the specified key. Events are decoded into API objects,
	// and any items selected by 'p' are sent down to returned watch.Interface.
	// resourceVersion may be used to specify what version to begin watching,
	// which should be the current resourceVersion, and no longer rv+1
	// (e.g. reconnecting without missing any updates).
	// If resource version is "0", this interface will get current object at given key
	// and send it in an "ADDED" event, before watch starts.
	Watch(ctx context.Context, key string, opts storage.ListOptions) (watch.Interface, error)

	// Get unmarshals object found at key into objPtr. On a not found error, will either
	// return a zero object of the requested type, or an error, depending on 'opts.ignoreNotFound'.
	// Treats empty responses and nil response nodes exactly like a not found error.
	// The returned contents may be delayed, but it is guaranteed that they will
	// match 'opts.ResourceVersion' according 'opts.ResourceVersionMatch'.
	Get(ctx context.Context, key string, opts storage.GetOptions, objPtr runtime.Object) error

	// GetList unmarshalls objects found at key into a *List api object (an object
	// that satisfies runtime.IsList definition).
	// If 'opts.Recursive' is false, 'key' is used as an exact match. If `opts.Recursive'
	// is true, 'key' is used as a prefix.
	// The returned contents may be delayed, but it is guaranteed that they will
	// match 'opts.ResourceVersion' according 'opts.ResourceVersionMatch'.
	GetList(ctx context.Context, key string, opts storage.ListOptions, listObj runtime.Object) error

	// GuaranteedUpdate keeps calling 'tryUpdate()' to update key 'key' (of type 'destination')
	// retrying the update until success if there is index conflict.
	// Note that object passed to tryUpdate may change across invocations of tryUpdate() if
	// other writers are simultaneously updating it, so tryUpdate() needs to take into account
	// the current contents of the object when deciding how the update object should look.
	// If the key doesn't exist, it will return NotFound storage error if ignoreNotFound=false
	// else `destination` will be set to the zero value of it's type.
	// If the eventual successful invocation of `tryUpdate` returns an output with the same serialized
	// contents as the input, it won't perform any update, but instead set `destination` to an object with those
	// contents.
	// If 'cachedExistingObject' is non-nil, it can be used as a suggestion about the
	// current version of the object to avoid read operation from storage to get it.
	// However, the implementations have to retry in case suggestion is stale.
	//
	// Example:
	//
	// s := /* implementation of Interface */
	// err := s.GuaranteedUpdate(
	//     "myKey", &MyType{}, true, preconditions,
	//     func(input runtime.Object, res ResponseMeta) (runtime.Object, *uint64, error) {
	//       // Before each invocation of the user defined function, "input" is reset to
	//       // current contents for "myKey" in database.
	//       curr := input.(*MyType)  // Guaranteed to succeed.
	//
	//       // Make the modification
	//       curr.Counter++
	//
	//       // Return the modified object - return an error to stop iterating. Return
	//       // a uint64 to alter the TTL on the object, or nil to keep it the same value.
	//       return cur, nil, nil
	//    }, cachedExistingObject
	// )
	GuaranteedUpdate(
		ctx context.Context, key string, destination runtime.Object, ignoreNotFound bool,
		preconditions *storage.Preconditions, tryUpdate storage.UpdateFunc, cachedExistingObject runtime.Object) error

	// Count returns number of different entries under the key (generally being path prefix).
	Count(key string) (int64, error)
}

type StoreRehydrationMode string

type Stream[In ReferenceObject, Out any] func(context.Context, In) (chan Out, chan error, error)

type StreamClient[In ReferenceObject, Out any] struct {
	// contains filtered or unexported fields
}

type StreamStrategy[In ReferenceObject, Out any] interface {
	// Channel performs the request with the provide input In and returns a
	// channel which allows returning a stream of content.  Any issues from the
	// stream itself will be propagated back through the error channel.
	// Initialization errors are returned through the standard error.
	Channel(context.Context, In) (chan Out, chan error, error)
}