





'''simple docstring'''

from ..utils import DummyObject, requires_backends






class    UpperCAmelCase	(       metaclass=UpperCamelCase__				):
 __lowercase   		=				["""flax"""]
 def __init__(				self      :List[str]						,       *lowercase_      :List[Any]						,       **lowercase_      :Optional[int]							)->							Union[str, Any]:
     requires_backends(self						,       ["flax"]							)
 @classmethod
 def      UpperCAmelCase_							(				cls      :Dict						,       *lowercase_      :Union[str, Any]						,       **lowercase_      :Dict							)->							Any:
     requires_backends(cls						,       ["flax"]							)



 @classmethod
 def      UpperCAmelCase_							(				cls      :int						,       *lowercase_      :Any						,       **lowercase_      :Any							)->							str:
     requires_backends(cls						,       ["flax"]							)






class    UpperCAmelCase	(       metaclass=UpperCamelCase__				):
 __lowercase   		=				["""flax"""]
 def __init__(				self      :Optional[Any]						,       *lowercase_      :List[str]						,       **lowercase_      :str							)->							List[Any]:
     requires_backends(self						,       ["flax"]							)
 @classmethod
 def      UpperCAmelCase_							(				cls      :Optional[int]						,       *lowercase_      :Union[str, Any]						,       **lowercase_      :Union[str, Any]							)->							Dict:
     requires_backends(cls						,       ["flax"]							)



 @classmethod
 def      UpperCAmelCase_							(				cls      :Any						,       *lowercase_      :Optional[Any]						,       **lowercase_      :Union[str, Any]							)->							Any:
     requires_backends(cls						,       ["flax"]							)






class    UpperCAmelCase	(       metaclass=UpperCamelCase__				):
 __lowercase   		=				["""flax"""]
 def __init__(				self      :Tuple						,       *lowercase_      :Any						,       **lowercase_      :int							)->							str:
     requires_backends(self						,       ["flax"]							)
 @classmethod
 def      UpperCAmelCase_							(				cls      :Dict						,       *lowercase_      :Optional[int]						,       **lowercase_      :Optional[Any]							)->							List[str]:
     requires_backends(cls						,       ["flax"]							)



 @classmethod
 def      UpperCAmelCase_							(				cls      :List[Any]						,       *lowercase_      :Optional[Any]						,       **lowercase_      :List[Any]							)->							Optional[int]:
     requires_backends(cls						,       ["flax"]							)






class    UpperCAmelCase	(       metaclass=UpperCamelCase__				):
 __lowercase   		=				["""flax"""]
 def __init__(				self      :Optional[int]						,       *lowercase_      :Tuple						,       **lowercase_      :Any							)->							List[str]:
     requires_backends(self						,       ["flax"]							)
 @classmethod
 def      UpperCAmelCase_							(				cls      :Optional[int]						,       *lowercase_      :Dict						,       **lowercase_      :List[str]							)->							Optional[int]:
     requires_backends(cls						,       ["flax"]							)



 @classmethod
 def      UpperCAmelCase_							(				cls      :str						,       *lowercase_      :Union[str, Any]						,       **lowercase_      :str							)->							Dict:
     requires_backends(cls						,       ["flax"]							)






class    UpperCAmelCase	(       metaclass=UpperCamelCase__				):
 __lowercase   		=				["""flax"""]
 def __init__(				self      :Dict						,       *lowercase_      :Union[str, Any]						,       **lowercase_      :str							)->							int:
     requires_backends(self						,       ["flax"]							)
 @classmethod
 def      UpperCAmelCase_							(				cls      :Optional[Any]						,       *lowercase_      :str						,       **lowercase_      :Optional[int]							)->							Optional[int]:
     requires_backends(cls						,       ["flax"]							)



 @classmethod
 def      UpperCAmelCase_							(				cls      :Any						,       *lowercase_      :List[Any]						,       **lowercase_      :Dict							)->							Optional[Any]:
     requires_backends(cls						,       ["flax"]							)






class    UpperCAmelCase	(       metaclass=UpperCamelCase__				):
 __lowercase   		=				["""flax"""]
 def __init__(				self      :Tuple						,       *lowercase_      :Tuple						,       **lowercase_      :Union[str, Any]							)->							str:
     requires_backends(self						,       ["flax"]							)
 @classmethod
 def      UpperCAmelCase_							(				cls      :int						,       *lowercase_      :Dict						,       **lowercase_      :int							)->							Optional[int]:
     requires_backends(cls						,       ["flax"]							)



 @classmethod
 def      UpperCAmelCase_							(				cls      :List[Any]						,       *lowercase_      :Union[str, Any]						,       **lowercase_      :int							)->							int:
     requires_backends(cls						,       ["flax"]							)






class    UpperCAmelCase	(       metaclass=UpperCamelCase__				):
 __lowercase   		=				["""flax"""]
 def __init__(				self      :Any						,       *lowercase_      :Tuple						,       **lowercase_      :Tuple							)->							str:
     requires_backends(self						,       ["flax"]							)
 @classmethod
 def      UpperCAmelCase_							(				cls      :List[Any]						,       *lowercase_      :Any						,       **lowercase_      :int							)->							List[str]:
     requires_backends(cls						,       ["flax"]							)



 @classmethod
 def      UpperCAmelCase_							(				cls      :Dict						,       *lowercase_      :int						,       **lowercase_      :int							)->							Dict:
     requires_backends(cls						,       ["flax"]							)






class    UpperCAmelCase	(       metaclass=UpperCamelCase__				):
 __lowercase   		=				["""flax"""]
 def __init__(				self      :List[str]						,       *lowercase_      :Optional[int]						,       **lowercase_      :Union[str, Any]							)->							Dict:
     requires_backends(self						,       ["flax"]							)
 @classmethod
 def      UpperCAmelCase_							(				cls      :List[str]						,       *lowercase_      :Union[str, Any]						,       **lowercase_      :Optional[Any]							)->							int:
     requires_backends(cls						,       ["flax"]							)



 @classmethod
 def      UpperCAmelCase_							(				cls      :Union[str, Any]						,       *lowercase_      :Dict						,       **lowercase_      :Dict							)->							List[str]:
     requires_backends(cls						,       ["flax"]							)






class    UpperCAmelCase	(       metaclass=UpperCamelCase__				):
 __lowercase   		=				["""flax"""]
 def __init__(				self      :Dict						,       *lowercase_      :Optional[Any]						,       **lowercase_      :List[str]							)->							Any:
     requires_backends(self						,       ["flax"]							)
 @classmethod
 def      UpperCAmelCase_							(				cls      :List[Any]						,       *lowercase_      :int						,       **lowercase_      :Dict							)->							Union[str, Any]:
     requires_backends(cls						,       ["flax"]							)



 @classmethod
 def      UpperCAmelCase_							(				cls      :List[Any]						,       *lowercase_      :Optional[Any]						,       **lowercase_      :Any							)->							Any:
     requires_backends(cls						,       ["flax"]							)






class    UpperCAmelCase	(       metaclass=UpperCamelCase__				):
 __lowercase   		=				["""flax"""]
 def __init__(				self      :Optional[int]						,       *lowercase_      :Any						,       **lowercase_      :int							)->							str:
     requires_backends(self						,       ["flax"]							)
 @classmethod
 def      UpperCAmelCase_							(				cls      :int						,       *lowercase_      :Union[str, Any]						,       **lowercase_      :int							)->							Any:
     requires_backends(cls						,       ["flax"]							)



 @classmethod
 def      UpperCAmelCase_							(				cls      :Tuple						,       *lowercase_      :Optional[int]						,       **lowercase_      :Any							)->							Tuple:
     requires_backends(cls						,       ["flax"]							)






class    UpperCAmelCase	(       metaclass=UpperCamelCase__				):
 __lowercase   		=				["""flax"""]
 def __init__(				self      :List[Any]						,       *lowercase_      :Optional[Any]						,       **lowercase_      :Dict							)->							List[str]:
     requires_backends(self						,       ["flax"]							)
 @classmethod
 def      UpperCAmelCase_							(				cls      :Tuple						,       *lowercase_      :int						,       **lowercase_      :Optional[int]							)->							Dict:
     requires_backends(cls						,       ["flax"]							)



 @classmethod
 def      UpperCAmelCase_							(				cls      :List[Any]						,       *lowercase_      :Tuple						,       **lowercase_      :List[Any]							)->							Union[str, Any]:
     requires_backends(cls						,       ["flax"]							)






class    UpperCAmelCase	(       metaclass=UpperCamelCase__				):
 __lowercase   		=				["""flax"""]
 def __init__(				self      :List[str]						,       *lowercase_      :str						,       **lowercase_      :Any							)->							Any:
     requires_backends(self						,       ["flax"]							)
 @classmethod
 def      UpperCAmelCase_							(				cls      :List[Any]						,       *lowercase_      :Any						,       **lowercase_      :List[Any]							)->							int:
     requires_backends(cls						,       ["flax"]							)



 @classmethod
 def      UpperCAmelCase_							(				cls      :List[str]						,       *lowercase_      :Tuple						,       **lowercase_      :str							)->							List[str]:
     requires_backends(cls						,       ["flax"]							)






class    UpperCAmelCase	(       metaclass=UpperCamelCase__				):
 __lowercase   		=				["""flax"""]
 def __init__(				self      :Union[str, Any]						,       *lowercase_      :int						,       **lowercase_      :int							)->							Optional[Any]:
     requires_backends(self						,       ["flax"]							)
 @classmethod
 def      UpperCAmelCase_							(				cls      :int						,       *lowercase_      :Tuple						,       **lowercase_      :Dict							)->							str:
     requires_backends(cls						,       ["flax"]							)



 @classmethod
 def      UpperCAmelCase_							(				cls      :Optional[Any]						,       *lowercase_      :int						,       **lowercase_      :List[str]							)->							List[Any]:
     requires_backends(cls						,       ["flax"]							)










'''simple docstring'''

# NOTE: This file is deprecated and will be removed in a future version.
# It only exists so that temporarely `from diffusers.pipelines import DiffusionPipeline` works
from ...utils import deprecate
from ..controlnet.multicontrolnet import MultiControlNetModel  # noqa: F401
from ..controlnet.pipeline_controlnet import StableDiffusionControlNetPipeline  # noqa: F401


deprecate(
    "stable diffusion controlnet",
    "0.22.0",
    "Importing `StableDiffusionControlNetPipeline` or `MultiControlNetModel` from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet is deprecated. Please import `from diffusers import StableDiffusionControlNetPipeline` instead.",
    standard_warn=False,
    stacklevel=3,
)



