"""
Python module generated from Java source file com.google.common.base.Preconditions

Java source file obtained from artifact guava version 21.0

Because this Python module is automatically generated, it may contain errors
and/or code that cannot be parsed. Please report these issues at
https://github.com/magicmq/docs-translator/issues
"""
from com.google.common.annotations import GwtCompatible
from com.google.common.base import *
from com.google.errorprone.annotations import CanIgnoreReturnValue
from javax.annotation import Nullable
from typing import Any, Callable, Iterable, Tuple


class Preconditions:
    """
    Static convenience methods that help a method or constructor check whether it was invoked
    correctly (whether its *preconditions* have been met). These methods generally accept a
    `boolean` expression which is expected to be `True` (or in the case of `checkNotNull`, an object reference which is expected to be non-null). When `False` (or
    `null`) is passed instead, the `Preconditions` method throws an unchecked exception,
    which helps the calling method communicate to *its* caller that *that* caller has made
    a mistake. Example: ```   `/**
       * Returns the positive square root of the given value.
       *
       * @throws IllegalArgumentException if the value is negative
       *``/
      public static double sqrt(double value) {
        Preconditions.checkArgument(value >= 0.0, "negative value: %s", value);
        // calculate the square root`
    
      void exampleBadCaller() {
        double d = sqrt(-1.0);
      }}```
    
    In this example, `checkArgument` throws an `IllegalArgumentException` to indicate
    that `exampleBadCaller` made an error in *its* call to `sqrt`.
    
    <h3>Warning about performance</h3>
    
    The goal of this class is to improve readability of code, but in some circumstances this may
    come at a significant performance cost. Remember that parameter values for message construction
    must all be computed eagerly, and autoboxing and varargs array creation may happen as well, even
    when the precondition check then succeeds (as it should almost always do in production). In some
    circumstances these wasted CPU cycles and allocations can add up to a real problem.
    Performance-sensitive precondition checks can always be converted to the customary form:
    ```   `if (value < 0.0) {
        throw new IllegalArgumentException("negative value: " + value);`}```
    
    <h3>Other types of preconditions</h3>
    
    Not every type of precondition failure is supported by these methods. Continue to throw
    standard JDK exceptions such as java.util.NoSuchElementException or
    UnsupportedOperationException in the situations they are intended for.
    
    <h3>Non-preconditions</h3>
    
    It is of course possible to use the methods of this class to check for invalid conditions
    which are *not the caller's fault*. Doing so is **not recommended** because it is
    misleading to future readers of the code and of stack traces. See
    <a href="https://github.com/google/guava/wiki/ConditionalFailuresExplained">Conditional failures
    explained</a> in the Guava User Guide for more advice.
    
    <h3>`java.util.Objects.requireNonNull()`</h3>
    
    Projects which use `com.google.common` should generally avoid the use of
    java.util.Objects.requireNonNull(Object). Instead, use whichever of
    .checkNotNull(Object) or Verify.verifyNotNull(Object) is appropriate to the
    situation. (The same goes for the message-accepting overloads.)
    
    <h3>Only `%s` is supported</h3>
    
    In `Preconditions` error message template strings, only the `"%s"` specifier is
    supported, not the full range of java.util.Formatter specifiers.
    
    <h3>More information</h3>
    
    See the Guava User Guide on
    <a href="https://github.com/google/guava/wiki/PreconditionsExplained">using `Preconditions`</a>.

    Author(s)
    - Kevin Bourrillion

    Since
    - 2.0
    """

    @staticmethod
    def checkArgument(expression: bool) -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.

        Arguments
        - expression: a boolean expression

        Raises
        - IllegalArgumentException: if `expression` is False
        """
        ...


    @staticmethod
    def checkArgument(expression: bool, errorMessage: "Object") -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.

        Arguments
        - expression: a boolean expression
        - errorMessage: the exception message to use if the check fails; will be converted to a
            string using String.valueOf(Object)

        Raises
        - IllegalArgumentException: if `expression` is False
        """
        ...


    @staticmethod
    def checkArgument(expression: bool, errorMessageTemplate: str, *errorMessageArgs: Tuple["Object", ...]) -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.

        Arguments
        - expression: a boolean expression
        - errorMessageTemplate: a template for the exception message should the check fail. The
            message is formed by replacing each `%s` placeholder in the template with an
            argument. These are matched by position - the first `%s` gets `errorMessageArgs[0]`, etc. Unmatched arguments will be appended to the formatted message in
            square braces. Unmatched placeholders will be left as-is.
        - errorMessageArgs: the arguments to be substituted into the message template. Arguments
            are converted to strings using String.valueOf(Object).

        Raises
        - IllegalArgumentException: if `expression` is False
        - NullPointerException: if the check fails and either `errorMessageTemplate` or
            `errorMessageArgs` is null (don't let this happen)
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: str) -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: int) -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: int) -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: "Object") -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: str, p2: str) -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: str, p2: int) -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: str, p2: int) -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: str, p2: "Object") -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: int, p2: str) -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: int, p2: int) -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: int, p2: int) -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: int, p2: "Object") -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: int, p2: str) -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: int, p2: int) -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: int, p2: int) -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: int, p2: "Object") -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: "Object", p2: str) -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: "Object", p2: int) -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: "Object", p2: int) -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: "Object", p2: "Object") -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: "Object", p2: "Object", p3: "Object") -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkArgument(b: bool, errorMessageTemplate: str, p1: "Object", p2: "Object", p3: "Object", p4: "Object") -> None:
        """
        Ensures the truth of an expression involving one or more parameters to the calling method.
        
        See .checkArgument(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(expression: bool) -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.

        Arguments
        - expression: a boolean expression

        Raises
        - IllegalStateException: if `expression` is False
        """
        ...


    @staticmethod
    def checkState(expression: bool, errorMessage: "Object") -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.

        Arguments
        - expression: a boolean expression
        - errorMessage: the exception message to use if the check fails; will be converted to a
            string using String.valueOf(Object)

        Raises
        - IllegalStateException: if `expression` is False
        """
        ...


    @staticmethod
    def checkState(expression: bool, errorMessageTemplate: str, *errorMessageArgs: Tuple["Object", ...]) -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.

        Arguments
        - expression: a boolean expression
        - errorMessageTemplate: a template for the exception message should the check fail. The
            message is formed by replacing each `%s` placeholder in the template with an
            argument. These are matched by position - the first `%s` gets `errorMessageArgs[0]`, etc. Unmatched arguments will be appended to the formatted message in
            square braces. Unmatched placeholders will be left as-is.
        - errorMessageArgs: the arguments to be substituted into the message template. Arguments
            are converted to strings using String.valueOf(Object).

        Raises
        - IllegalStateException: if `expression` is False
        - NullPointerException: if the check fails and either `errorMessageTemplate` or
            `errorMessageArgs` is null (don't let this happen)
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: str) -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: int) -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: int) -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: "Object") -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: str, p2: str) -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: str, p2: int) -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: str, p2: int) -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: str, p2: "Object") -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: int, p2: str) -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: int, p2: int) -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: int, p2: int) -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: int, p2: "Object") -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: int, p2: str) -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: int, p2: int) -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: int, p2: int) -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: int, p2: "Object") -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: "Object", p2: str) -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: "Object", p2: int) -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: "Object", p2: int) -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: "Object", p2: "Object") -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: "Object", p2: "Object", p3: "Object") -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkState(b: bool, errorMessageTemplate: str, p1: "Object", p2: "Object", p3: "Object", p4: "Object") -> None:
        """
        Ensures the truth of an expression involving the state of the calling instance, but not
        involving any parameters to the calling method.
        
        See .checkState(boolean, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(reference: "T") -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.

        Arguments
        - reference: an object reference

        Returns
        - the non-null reference that was validated

        Raises
        - NullPointerException: if `reference` is null
        """
        ...


    @staticmethod
    def checkNotNull(reference: "T", errorMessage: "Object") -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.

        Arguments
        - reference: an object reference
        - errorMessage: the exception message to use if the check fails; will be converted to a
            string using String.valueOf(Object)

        Returns
        - the non-null reference that was validated

        Raises
        - NullPointerException: if `reference` is null
        """
        ...


    @staticmethod
    def checkNotNull(reference: "T", errorMessageTemplate: str, *errorMessageArgs: Tuple["Object", ...]) -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.

        Arguments
        - reference: an object reference
        - errorMessageTemplate: a template for the exception message should the check fail. The
            message is formed by replacing each `%s` placeholder in the template with an
            argument. These are matched by position - the first `%s` gets `errorMessageArgs[0]`, etc. Unmatched arguments will be appended to the formatted message in
            square braces. Unmatched placeholders will be left as-is.
        - errorMessageArgs: the arguments to be substituted into the message template. Arguments
            are converted to strings using String.valueOf(Object).

        Returns
        - the non-null reference that was validated

        Raises
        - NullPointerException: if `reference` is null
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: str) -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: int) -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: int) -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: "Object") -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: str, p2: str) -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: str, p2: int) -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: str, p2: int) -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: str, p2: "Object") -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: int, p2: str) -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: int, p2: int) -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: int, p2: int) -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: int, p2: "Object") -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: int, p2: str) -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: int, p2: int) -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: int, p2: int) -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: int, p2: "Object") -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: "Object", p2: str) -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: "Object", p2: int) -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: "Object", p2: int) -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: "Object", p2: "Object") -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: "Object", p2: "Object", p3: "Object") -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkNotNull(obj: "T", errorMessageTemplate: str, p1: "Object", p2: "Object", p3: "Object", p4: "Object") -> "T":
        """
        Ensures that an object reference passed as a parameter to the calling method is not null.
        
        See .checkNotNull(Object, String, Object...) for details.
        """
        ...


    @staticmethod
    def checkElementIndex(index: int, size: int) -> int:
        """
        Ensures that `index` specifies a valid *element* in an array, list or string of size
        `size`. An element index may range from zero, inclusive, to `size`, exclusive.

        Arguments
        - index: a user-supplied index identifying an element of an array, list or string
        - size: the size of that array, list or string

        Returns
        - the value of `index`

        Raises
        - IndexOutOfBoundsException: if `index` is negative or is not less than `size`
        - IllegalArgumentException: if `size` is negative
        """
        ...


    @staticmethod
    def checkElementIndex(index: int, size: int, desc: str) -> int:
        """
        Ensures that `index` specifies a valid *element* in an array, list or string of size
        `size`. An element index may range from zero, inclusive, to `size`, exclusive.

        Arguments
        - index: a user-supplied index identifying an element of an array, list or string
        - size: the size of that array, list or string
        - desc: the text to use to describe this index in an error message

        Returns
        - the value of `index`

        Raises
        - IndexOutOfBoundsException: if `index` is negative or is not less than `size`
        - IllegalArgumentException: if `size` is negative
        """
        ...


    @staticmethod
    def checkPositionIndex(index: int, size: int) -> int:
        """
        Ensures that `index` specifies a valid *position* in an array, list or string of
        size `size`. A position index may range from zero to `size`, inclusive.

        Arguments
        - index: a user-supplied index identifying a position in an array, list or string
        - size: the size of that array, list or string

        Returns
        - the value of `index`

        Raises
        - IndexOutOfBoundsException: if `index` is negative or is greater than `size`
        - IllegalArgumentException: if `size` is negative
        """
        ...


    @staticmethod
    def checkPositionIndex(index: int, size: int, desc: str) -> int:
        """
        Ensures that `index` specifies a valid *position* in an array, list or string of
        size `size`. A position index may range from zero to `size`, inclusive.

        Arguments
        - index: a user-supplied index identifying a position in an array, list or string
        - size: the size of that array, list or string
        - desc: the text to use to describe this index in an error message

        Returns
        - the value of `index`

        Raises
        - IndexOutOfBoundsException: if `index` is negative or is greater than `size`
        - IllegalArgumentException: if `size` is negative
        """
        ...


    @staticmethod
    def checkPositionIndexes(start: int, end: int, size: int) -> None:
        """
        Ensures that `start` and `end` specify a valid *positions* in an array, list
        or string of size `size`, and are in order. A position index may range from zero to
        `size`, inclusive.

        Arguments
        - start: a user-supplied index identifying a starting position in an array, list or string
        - end: a user-supplied index identifying a ending position in an array, list or string
        - size: the size of that array, list or string

        Raises
        - IndexOutOfBoundsException: if either index is negative or is greater than `size`,
            or if `end` is less than `start`
        - IllegalArgumentException: if `size` is negative
        """
        ...
