code: def check_interval(
      interval: list = None,
      quantiles: float = None,
      alpha: float = None,
  ) -> None:
      """
      Check provided confidence interval sequence is valid.
  
      Parameters
      ----------
      interval : list, default `None`
          Confidence of the prediction interval estimated. Sequence of percentiles
          to compute, which must be between 0 and 100 inclusive. For example,
          interval of 95% should be as `interval = [2.5, 97.5]`.
      quantiles : list, default `None`
          Sequence of quantiles to compute, which must be between 0 and 1
          inclusive. For example, quantiles of 0.05, 0.5 and 0.95 should be as
          `quantiles = [0.05, 0.5, 0.95]`.
      alpha : float, default `None`
          The confidence intervals used in ForecasterSarimax are (1 - alpha) %.
  
      Returns
      -------
      None
  
      """
  
      if interval is not None:
          if not isinstance(interval, list):
              raise TypeError(
                  (
                      "`interval` must be a `list`. For example, interval of 95% "
                      "should be as `interval = [2.5, 97.5]`."
                  )
              )
  
          if len(interval) != 2:
              raise ValueError(
                  (
                      "`interval` must contain exactly 2 values, respectively the "
                      "lower and upper interval bounds. For example, interval of 95% "
                      "should be as `interval = [2.5, 97.5]`."
                  )
              )
  
          if (interval[0] < 0.0) or (interval[0] >= 100.0):
              raise ValueError(
                  f"Lower interval bound ({interval[0]}) must be >= 0 and < 100."
              )
  
          if (interval[1] <= 0.0) or (interval[1] > 100.0):
              raise ValueError(
                  f"Upper interval bound ({interval[1]}) must be > 0 and <= 100."
              )
  
          if interval[0] >= interval[1]:
              raise ValueError(
                  f"Lower interval bound ({interval[0]}) must be less than the "
                  f"upper interval bound ({interval[1]})."
              )
  
      if quantiles is not None:
          if not isinstance(quantiles, list):
              raise TypeError(
                  (
                      "`quantiles` must be a `list`. For example, quantiles 0.05, "
                      "0.5, and 0.95 should be as `quantiles = [0.05, 0.5, 0.95]`."
                  )
              )
  
          for q in quantiles:
              if (q < 0.0) or (q > 1.0):
                  raise ValueError(
                      (
                          "All elements in `quantiles` must be >= 0 and <= 1."
                      )
                  )
  
      if alpha is not None:
          if not isinstance(alpha, float):
              raise TypeError(
                  (
                      "`alpha` must be a `float`. For example, interval of 95% "
                      "should be as `alpha = 0.05`."
                  )
              )
  
          if (alpha <= 0.0) or (alpha >= 1):
              raise ValueError(
                  f"`alpha` must have a value between 0 and 1. Got {alpha}."
              )
  
      return
  
imports: from typing import Union, Any, Optional, Tuple, Callable
  import warnings
  import importlib
  import joblib
  import numpy
  import pandas
  import sklearn
  import sklearn.pipeline
  import sklearn.linear_model
  from sklearn.compose import ColumnTransformer
  from sklearn.exceptions import NotFittedError
  import inspect
  from copy import deepcopy
  import skforecast
  from ..exceptions import MissingValuesExogWarning
  from ..exceptions import DataTypeWarning
  from ..exceptions import IgnoredArgumentWarning
  from ..exceptions import SkforecastVersionWarning
label_desc: Use image node_id 9 for calling a global function with example usage: check_interval(interval, quantiles, alpha) without return types