
from ..utils import DummyObject, requires_backends




class 				lowerCamelCase__							(       metaclass=__lowercase):




	'''simple docstring'''




	_A			=  ['flax']







	def __init__(      self	:Tuple  ,     *a	:Optional[Any]  ,     **a	:Tuple		)	->				Optional[int]:
								requires_backends(self  ,     ["flax"]		)







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







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




class 				lowerCamelCase__							(       metaclass=__lowercase):




	'''simple docstring'''




	_A			=  ['flax']







	def __init__(      self	:Dict  ,     *a	:Tuple  ,     **a	:Dict		)	->				str:
								requires_backends(self  ,     ["flax"]		)







	@classmethod
	def      _lowerCamelCase       (      cls	:str  ,     *a	:Any  ,     **a	:Tuple		)	->				Dict:
								requires_backends(cls  ,     ["flax"]		)







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




class 				lowerCamelCase__							(       metaclass=__lowercase):




	'''simple docstring'''




	_A			=  ['flax']







	def __init__(      self	:str  ,     *a	:int  ,     **a	:int		)	->				str:
								requires_backends(self  ,     ["flax"]		)







	@classmethod
	def      _lowerCamelCase       (      cls	:Dict  ,     *a	:Optional[int]  ,     **a	:Any		)	->				Union[str, Any]:
								requires_backends(cls  ,     ["flax"]		)







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




class 				lowerCamelCase__							(       metaclass=__lowercase):




	'''simple docstring'''




	_A			=  ['flax']







	def __init__(      self	:Optional[int]  ,     *a	:Optional[int]  ,     **a	:Any		)	->				Optional[int]:
								requires_backends(self  ,     ["flax"]		)







	@classmethod
	def      _lowerCamelCase       (      cls	:Tuple  ,     *a	:int  ,     **a	:List[Any]		)	->				Tuple:
								requires_backends(cls  ,     ["flax"]		)







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




class 				lowerCamelCase__							(       metaclass=__lowercase):




	'''simple docstring'''




	_A			=  ['flax']







	def __init__(      self	:Optional[Any]  ,     *a	:Any  ,     **a	:int		)	->				Optional[int]:
								requires_backends(self  ,     ["flax"]		)







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







	@classmethod
	def      _lowerCamelCase       (      cls	:str  ,     *a	:int  ,     **a	:Tuple		)	->				Tuple:
								requires_backends(cls  ,     ["flax"]		)




class 				lowerCamelCase__							(       metaclass=__lowercase):




	'''simple docstring'''




	_A			=  ['flax']







	def __init__(      self	:str  ,     *a	:Optional[int]  ,     **a	:Optional[int]		)	->				List[str]:
								requires_backends(self  ,     ["flax"]		)







	@classmethod
	def      _lowerCamelCase       (      cls	:List[Any]  ,     *a	:Tuple  ,     **a	:Tuple		)	->				Optional[Any]:
								requires_backends(cls  ,     ["flax"]		)







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




class 				lowerCamelCase__							(       metaclass=__lowercase):




	'''simple docstring'''




	_A			=  ['flax']







	def __init__(      self	:str  ,     *a	:str  ,     **a	:str		)	->				List[str]:
								requires_backends(self  ,     ["flax"]		)







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







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




class 				lowerCamelCase__							(       metaclass=__lowercase):




	'''simple docstring'''




	_A			=  ['flax']







	def __init__(      self	:List[str]  ,     *a	:str  ,     **a	:Tuple		)	->				str:
								requires_backends(self  ,     ["flax"]		)







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







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




class 				lowerCamelCase__							(       metaclass=__lowercase):




	'''simple docstring'''




	_A			=  ['flax']







	def __init__(      self	:Tuple  ,     *a	:List[Any]  ,     **a	:int		)	->				List[Any]:
								requires_backends(self  ,     ["flax"]		)







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







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




class 				lowerCamelCase__							(       metaclass=__lowercase):




	'''simple docstring'''




	_A			=  ['flax']







	def __init__(      self	:Any  ,     *a	:Dict  ,     **a	:List[str]		)	->				int:
								requires_backends(self  ,     ["flax"]		)







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







	@classmethod
	def      _lowerCamelCase       (      cls	:Dict  ,     *a	:Optional[Any]  ,     **a	:Optional[Any]		)	->				Dict:
								requires_backends(cls  ,     ["flax"]		)




class 				lowerCamelCase__							(       metaclass=__lowercase):




	'''simple docstring'''




	_A			=  ['flax']







	def __init__(      self	:Tuple  ,     *a	:Dict  ,     **a	:Tuple		)	->				List[Any]:
								requires_backends(self  ,     ["flax"]		)







	@classmethod
	def      _lowerCamelCase       (      cls	:Union[str, Any]  ,     *a	:Dict  ,     **a	:Optional[Any]		)	->				Optional[int]:
								requires_backends(cls  ,     ["flax"]		)







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




class 				lowerCamelCase__							(       metaclass=__lowercase):




	'''simple docstring'''




	_A			=  ['flax']







	def __init__(      self	:Union[str, Any]  ,     *a	:List[Any]  ,     **a	:List[Any]		)	->				Union[str, Any]:
								requires_backends(self  ,     ["flax"]		)







	@classmethod
	def      _lowerCamelCase       (      cls	:int  ,     *a	:List[str]  ,     **a	:int		)	->				List[str]:
								requires_backends(cls  ,     ["flax"]		)







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




class 				lowerCamelCase__							(       metaclass=__lowercase):




	'''simple docstring'''




	_A			=  ['flax']







	def __init__(      self	:Tuple  ,     *a	:List[str]  ,     **a	:Optional[Any]		)	->				Optional[int]:
								requires_backends(self  ,     ["flax"]		)







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







	@classmethod
	def      _lowerCamelCase       (      cls	:Optional[Any]  ,     *a	:Optional[Any]  ,     **a	:Tuple		)	->				List[str]:
								requires_backends(cls  ,     ["flax"]		)

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase						:      Tuple									= {
    'configuration_swinv2': ['SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP', 'Swinv2Config'],
}


try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase						:      Union[str, Any]									= [
		    'SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'Swinv2ForImageClassification',
		    'Swinv2ForMaskedImageModeling',
		    'Swinv2Model',
		    'Swinv2PreTrainedModel',
		]


if TYPE_CHECKING:
		from .configuration_swinva import SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP, SwinvaConfig

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_swinva import (
				    SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST,
				    SwinvaForImageClassification,
				    SwinvaForMaskedImageModeling,
				    SwinvaModel,
				    SwinvaPreTrainedModel,
				)


else:
		import sys

		lowercase						:      Optional[Any]									= _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)