func NewErrTooManyRequests(message string) ErrTooManyRequests {
	fmt.Println("DEPRECATED: This function is deprecated. Please use simple constructor")
	return ErrTooManyRequests{Err: fmt.Errorf("%s", message)}
}
NewErrTooManyRequests returns a new ErrTooManyRequests.

Deprecated: this method is deprecated and should not be used anymore.
package manipulate
import "fmt"
type ErrInvalidQuery struct {
	DueToFilter bool
	Err         error
}
func (err ErrInvalidQuery) Unwrap() error {
	return err.Err
}
func (err ErrInvalidQuery) Error() string {
	return fmt.Sprintf("Query invalid: %s", err.Err)
}
type ErrCannotUnmarshal struct{ Err error }
func NewErrCannotUnmarshal(message string) ErrCannotUnmarshal {
	fmt.Println("DEPRECATED: This function is deprecated. Please use simple constructor")
	return ErrCannotUnmarshal{Err: fmt.Errorf("%s", message)}
}
func (e ErrCannotUnmarshal) Unwrap() error { return e.Err }
func (e ErrCannotUnmarshal) Error() string { return "Unable to unmarshal data: " + e.Err.Error() }
func IsCannotUnmarshalError(err error) bool {
	_, ok := err.(ErrCannotUnmarshal)
	return ok
}
type ErrCannotMarshal struct{ Err error }
func NewErrCannotMarshal(message string) ErrCannotMarshal {
	fmt.Println("DEPRECATED: This function is deprecated. Please use simple constructor")
	return ErrCannotMarshal{Err: fmt.Errorf("%s", message)}
}
func (e ErrCannotMarshal) Unwrap() error { return e.Err }
func (e ErrCannotMarshal) Error() string { return "Unable to marshal data: " + e.Err.Error() }
func IsCannotMarshalError(err error) bool {
	_, ok := err.(ErrCannotMarshal)
	return ok
}
type ErrObjectNotFound struct{ Err error }
func NewErrObjectNotFound(message string) ErrObjectNotFound {
	fmt.Println("DEPRECATED: This function is deprecated. Please use simple constructor")
	return ErrObjectNotFound{Err: fmt.Errorf("%s", message)}
}
func (e ErrObjectNotFound) Unwrap() error { return e.Err }
func (e ErrObjectNotFound) Error() string { return "Object not found: " + e.Err.Error() }
func IsObjectNotFoundError(err error) bool {
	_, ok := err.(ErrObjectNotFound)
	return ok
}
type ErrMultipleObjectsFound struct{ Err error }
func NewErrMultipleObjectsFound(message string) ErrMultipleObjectsFound {
	fmt.Println("DEPRECATED: This function is deprecated. Please use simple constructor")
	return ErrMultipleObjectsFound{Err: fmt.Errorf("%s", message)}
}
func (e ErrMultipleObjectsFound) Unwrap() error { return e.Err }
func (e ErrMultipleObjectsFound) Error() string { return "Multiple objects found: " + e.Err.Error() }
func IsMultipleObjectsFoundError(err error) bool {
	_, ok := err.(ErrMultipleObjectsFound)
	return ok
}
type ErrCannotBuildQuery struct{ Err error }
func NewErrCannotBuildQuery(message string) ErrCannotBuildQuery {
	fmt.Println("DEPRECATED: This function is deprecated. Please use simple constructor")
	return ErrCannotBuildQuery{Err: fmt.Errorf("%s", message)}
}
func (e ErrCannotBuildQuery) Unwrap() error { return e.Err }
func (e ErrCannotBuildQuery) Error() string { return "Unable to build query: " + e.Err.Error() }
func IsCannotBuildQueryError(err error) bool {
	_, ok := err.(ErrCannotBuildQuery)
	return ok
}
type ErrCannotExecuteQuery struct{ Err error }
func NewErrCannotExecuteQuery(message string) ErrCannotExecuteQuery {
	fmt.Println("DEPRECATED: This function is deprecated. Please use simple constructor")
	return ErrCannotExecuteQuery{Err: fmt.Errorf("%s", message)}
}
func (e ErrCannotExecuteQuery) Unwrap() error { return e.Err }
func (e ErrCannotExecuteQuery) Error() string { return "Unable to execute query: " + e.Err.Error() }
func IsCannotExecuteQueryError(err error) bool {
	_, ok := err.(ErrCannotExecuteQuery)
	return ok
}
type ErrCannotCommit struct{ Err error }
func NewErrCannotCommit(message string) ErrCannotCommit {
	fmt.Println("DEPRECATED: This function is deprecated. Please use simple constructor")
	return ErrCannotCommit{Err: fmt.Errorf("%s", message)}
}
func (e ErrCannotCommit) Unwrap() error { return e.Err }
func (e ErrCannotCommit) Error() string { return "Unable to commit transaction: " + e.Err.Error() }
func IsCannotCommitError(err error) bool {
	_, ok := err.(ErrCannotCommit)
	return ok
}
type ErrNotImplemented struct{ Err error }
func NewErrNotImplemented(message string) ErrNotImplemented {
	fmt.Println("DEPRECATED: This function is deprecated. Please use simple constructor")
	return ErrNotImplemented{Err: fmt.Errorf("%s", message)}
}
func (e ErrNotImplemented) Unwrap() error { return e.Err }
func (e ErrNotImplemented) Error() string { return "Not implemented: " + e.Err.Error() }
func IsNotImplementedError(err error) bool {
	_, ok := err.(ErrNotImplemented)
	return ok
}
type ErrCannotCommunicate struct{ Err error }
func NewErrCannotCommunicate(message string) ErrCannotCommunicate {
	fmt.Println("DEPRECATED: This function is deprecated. Please use simple constructor")
	return ErrCannotCommunicate{Err: fmt.Errorf("%s", message)}
}
func (e ErrCannotCommunicate) Unwrap() error { return e.Err }
func (e ErrCannotCommunicate) Error() string { return "Cannot communicate: " + e.Err.Error() }
func IsCannotCommunicateError(err error) bool {
	_, ok := err.(ErrCannotCommunicate)
	return ok
}
type ErrLocked struct{ Err error }
func NewErrLocked(message string) ErrLocked {
	fmt.Println("DEPRECATED: This function is deprecated. Please use simple constructor")
	return ErrLocked{Err: fmt.Errorf("%s", message)}
}
func (e ErrLocked) Unwrap() error { return e.Err }
func (e ErrLocked) Error() string { return "Cannot communicate: " + e.Err.Error() }
func IsLockedError(err error) bool {
	_, ok := err.(ErrLocked)
	return ok
}
type ErrTransactionNotFound struct{ Err error }
func NewErrTransactionNotFound(message string) ErrTransactionNotFound {
	fmt.Println("DEPRECATED: This function is deprecated. Please use simple constructor")
	return ErrTransactionNotFound{Err: fmt.Errorf("%s", message)}
}
func (e ErrTransactionNotFound) Unwrap() error { return e.Err }
func (e ErrTransactionNotFound) Error() string { return "Transaction not found: " + e.Err.Error() }
func IsTransactionNotFoundError(err error) bool {
	_, ok := err.(ErrTransactionNotFound)
	return ok
}
type ErrConstraintViolation struct{ Err error }
func NewErrConstraintViolation(message string) ErrConstraintViolation {
	fmt.Println("DEPRECATED: This function is deprecated. Please use simple constructor")
	return ErrConstraintViolation{Err: fmt.Errorf("%s", message)}
}
func (e ErrConstraintViolation) Unwrap() error { return e.Err }
func (e ErrConstraintViolation) Error() string { return "Constraint violation: " + e.Err.Error() }
func IsConstraintViolationError(err error) bool {
	_, ok := err.(ErrConstraintViolation)
	return ok
}
type ErrDisconnected struct{ Err error }
func NewErrDisconnected(message string) ErrDisconnected {
	fmt.Println("DEPRECATED: This function is deprecated. Please use simple constructor")
	return ErrDisconnected{Err: fmt.Errorf("%s", message)}
}
func (e ErrDisconnected) Unwrap() error { return e.Err }
func (e ErrDisconnected) Error() string { return "Disconnected: " + e.Err.Error() }
func IsDisconnectedError(err error) bool {
	_, ok := err.(ErrDisconnected)
	return ok
}
type ErrTooManyRequests struct{ Err error }