package fmt

import (
	"errors"
	"slices"
)

// Errorf formats according to a format specifier and returns the string as a
// value that satisfies error.
//
// If the format specifier includes a %w verb with an error operand,
// the returned error will implement an Unwrap method returning the operand.
// If there is more than one %w verb, the returned error will implement an

package admission

import (
	"errors"
	"fmt"

	"k8s.io/kubernetes/pkg/kubelet/lifecycle"
)

const (
	ErrorReasonUnexpected = "UnexpectedAdmissionError"
)

type Error interface {
	Error() string
	Type() string
}

type unexpectedAdmissionError struct{ Err error }

var _ Error = (*unexpectedAdmissionError)(nil)

func (e *unexpectedAdmissionError) Error() string {

*/

package endpointslice

// StaleInformerCache errors indicate that the informer cache includes out of
// date resources.
type StaleInformerCache struct {
	msg string
}

// NewStaleInformerCache return StaleInformerCache with error mes
func NewStaleInformerCache(msg string) *StaleInformerCache {
	return &StaleInformerCache{msg}
}

func (e *StaleInformerCache) Error() string { return e.msg }

type ChecksumMismatch struct {
	Want string
	Got  string
}

func (e ChecksumMismatch) Error() string {
	return "Bad checksum: Want " + e.Want + " does not match calculated " + e.Got
}

// IsChecksumMismatch matches if 'err' is hash.ChecksumMismatch
func IsChecksumMismatch(err error) bool {
	var herr ChecksumMismatch
	return errors.As(err, &herr)

	}
)

// Error is a KMS error that can be translated into an S3 API error.
//
// It does not implement the standard error Unwrap interface for
// better error log messages.
type Error struct {
	Code    int    // The HTTP status code returned to the client
	APICode string // The API error code identifying the error
	Err     string // The error message returned to the client
	Cause   error  // Optional, lower level error cause.
}

}

// ErrInvalidFilterName - invalid filter name error.
type ErrInvalidFilterName struct {
	FilterName string
}

func (err ErrInvalidFilterName) Error() string {
	return fmt.Sprintf("invalid filter name '%v'", err.FilterName)
}

// ErrFilterNamePrefix - more than one prefix usage error.
type ErrFilterNamePrefix struct{}

func (err ErrFilterNamePrefix) Error() string {
	return "more than one prefix in filter rule"
}

	message    string
	statusCode int
	cause      error
}

func (err *s3Error) Cause() error {
	return err.cause
}

func (err *s3Error) ErrorCode() string {
	return err.code
}

func (err *s3Error) ErrorMessage() string {
	return err.message
}

func (err *s3Error) HTTPStatusCode() int {
	return err.statusCode
}

func (err *s3Error) Error() string {
	return err.message
}

import (
	"fmt"
)

type LookupPatchMetaError struct {
	Path string
	Err  error
}

func (e LookupPatchMetaError) Error() string {
	return fmt.Sprintf("LookupPatchMetaError(%s): %v", e.Path, e.Err)
}

type FieldNotFoundError struct {
	Path  string
	Field string
}

func (e FieldNotFoundError) Error() string {
	return fmt.Sprintf("unable to find api field %q in %s", e.Field, e.Path)
}

limitations under the License.
*/

package cel

// Error is an implementation of the 'error' interface, which represents a
// XValidation error.
type Error struct {
	Type   ErrorType
	Detail string
}

var _ error = &Error{}

// Error implements the error interface.
func (v *Error) Error() string {
	return v.Detail
}

// It supports wrapped errors and returns StatusReasonUnknown when
// the error is nil or doesn't have a status.
func ReasonForError(err error) metav1.StatusReason {
	if status, ok := err.(APIStatus); ok || errors.As(err, &status) {
		return status.Status().Reason
	}
	return metav1.StatusReasonUnknown
}

func reasonAndCodeForError(err error) (metav1.StatusReason, int32) {