Adding upstream version 18.2.2.upstream/18.2.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

28 files changed, 15873 insertions, 0 deletions

diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/__init__.py b/src/pybind/mgr/rook/rook-client-python/rook_client/__init__.py
new file mode 100644
index 000000000..3fa2272dd
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/__init__.py
@@ -0,0 +1 @@
+from ._helper import STRICT
\ No newline at end of file
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/_helper.py b/src/pybind/mgr/rook/rook-client-python/rook_client/_helper.py
new file mode 100644
index 000000000..382d04c27
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/_helper.py
@@ -0,0 +1,128 @@
+import logging
+import sys
+try:
+    from typing import List, Dict, Any, Optional
+except ImportError:
+    pass
+
+logger = logging.getLogger(__name__)
+
+# Tricking mypy to think `_omit`'s type is NoneType
+# To make us not add things like `Union[Optional[str], OmitType]`
+NoneType = type(None)
+_omit = None  # type: NoneType
+_omit = object()  # type: ignore
+
+
+# Don't add any additionalProperties to objects. Useful for completeness testing
+STRICT = False
+
+def _str_to_class(cls, typ_str):
+    if isinstance(typ_str, str):
+        return getattr(sys.modules[cls.__module__], typ_str)
+    return typ_str
+
+
+def _property_from_json(cls, data, breadcrumb, name, py_name, typ_str, required, nullable):
+    if not required and name not in data:
+        return _omit
+    try:
+        obj = data[name]
+    except KeyError as e:
+        raise ValueError('KeyError in {}: {}'.format(breadcrumb, e))
+    if nullable and obj is None:
+        return obj
+    typ = _str_to_class(cls, typ_str)
+    if issubclass(typ, CrdObject) or issubclass(typ, CrdObjectList):
+        return typ.from_json(obj, breadcrumb + '.' + name)
+    return obj
+
+
+class CrdObject(object):
+    _properties = []  # type: List
+
+    def __init__(self, **kwargs):
+        for prop in self._properties:
+            setattr(self, prop[1], kwargs.pop(prop[1]))
+        if kwargs:
+            raise TypeError(
+                '{} got unexpected arguments {}'.format(self.__class__.__name__, kwargs.keys()))
+        self._additionalProperties = {}  # type: Dict[str, Any]
+
+    def _property_impl(self, name):
+        obj = getattr(self, '_' + name)
+        if obj is _omit:
+            raise AttributeError(name + ' not found')
+        return obj
+
+    def _property_to_json(self, name, py_name, typ_str, required, nullable):
+        obj = getattr(self, '_' + py_name)
+        typ = _str_to_class(self.__class__, typ_str)
+        if issubclass(typ, CrdObject) or issubclass(typ, CrdObjectList):
+            if nullable and obj is None:
+                return obj
+            if not required and obj is _omit:
+                return obj
+            return obj.to_json()
+        else:
+            return obj
+
+    def to_json(self):
+        # type: () -> Dict[str, Any]
+        res = {p[0]: self._property_to_json(*p) for p in self._properties}
+        res.update(self._additionalProperties)
+        return {k: v for k, v in res.items() if v is not _omit}
+
+    @classmethod
+    def from_json(cls, data, breadcrumb=''):
+        try:
+            sanitized = {
+                p[1]: _property_from_json(cls, data, breadcrumb, *p) for p in cls._properties
+            }
+            extra = {k:v for k,v in data.items() if k not in sanitized}
+            ret = cls(**sanitized)
+            ret._additionalProperties = {} if STRICT else extra
+            return ret
+        except (TypeError, AttributeError, KeyError):
+            logger.exception(breadcrumb)
+            raise
+
+
+class CrdClass(CrdObject):
+    @classmethod
+    def from_json(cls, data, breadcrumb=''):
+        kind = data['kind']
+        if kind != cls.__name__:
+            raise ValueError("kind mismatch: {} != {}".format(kind, cls.__name__))
+        return super(CrdClass, cls).from_json(data, breadcrumb)
+
+    def to_json(self):
+        ret = super(CrdClass, self).to_json()
+        ret['kind'] = self.__class__.__name__
+        return ret
+
+
+class CrdObjectList(list):
+    # Py3: Replace `Any` with `TypeVar('T_CrdObject', bound='CrdObject')`
+    _items_type = None  # type: Optional[Any]
+
+    def to_json(self):
+        # type: () -> List
+        if self._items_type is None:
+            return self
+        if issubclass(self._items_type, CrdObject) or issubclass(self._items_type, CrdObjectList):
+            return [e.to_json() for e in self]
+        return list(self)
+
+
+    @classmethod
+    def from_json(cls, data, breadcrumb=''):
+        if cls._items_type is None:
+            return cls(data)
+        if issubclass(cls._items_type, CrdObject) or issubclass(cls._items_type, CrdObjectList):
+            return cls(cls._items_type.from_json(e, breadcrumb + '[{}]'.format(i)) for i, e in enumerate(data))
+        return cls(data)
+
+    def __repr__(self):
+        return '{}({})'.format(self.__class__.__name__, repr(list(self)))
+
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/_helper.py.orig b/src/pybind/mgr/rook/rook-client-python/rook_client/_helper.py.orig
new file mode 100644
index 000000000..73ea7370f
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/_helper.py.orig
@@ -0,0 +1,133 @@
+import logging
+import sys
+try:
+    from typing import List, Dict, Any, Optional
+except ImportError:
+    pass
+
+logger = logging.getLogger(__name__)
+
+# Tricking mypy to think `_omit`'s type is NoneType
+# To make us not add things like `Union[Optional[str], OmitType]`
+NoneType = type(None)
+_omit = None  # type: NoneType
+_omit = object()  # type: ignore
+
+
+# Don't add any additionalProperties to objects. Useful for completeness testing
+STRICT = False
+
+def _str_to_class(cls, typ_str):
+    if isinstance(typ_str, str):
+        return getattr(sys.modules[cls.__module__], typ_str)
+    return typ_str
+
+
+def _property_from_json(cls, data, breadcrumb, name, py_name, typ_str, required, nullable):
+    if not required and name not in data:
+        return _omit
+    try:
+        obj = data[name]
+    except KeyError as e:
+        raise ValueError('KeyError in {}: {}'.format(breadcrumb, e))
+    if nullable and obj is None:
+        return obj
+    typ = _str_to_class(cls, typ_str)
+    if issubclass(typ, CrdObject) or issubclass(typ, CrdObjectList):
+        return typ.from_json(obj, breadcrumb + '.' + name)
+    return obj
+
+
+class CrdObject(object):
+    _properties = []  # type: List
+
+    def __init__(self, **kwargs):
+        for prop in self._properties:
+            setattr(self, prop[1], kwargs.pop(prop[1]))
+        if kwargs:
+            raise TypeError(
+                '{} got unexpected arguments {}'.format(self.__class__.__name__, kwargs.keys()))
+        self._additionalProperties = {}  # type: Dict[str, Any]
+
+    def _property_impl(self, name):
+        obj = getattr(self, '_' + name)
+        if obj is _omit:
+            raise AttributeError(name + ' not found')
+        return obj
+
+    def _property_to_json(self, name, py_name, typ_str, required, nullable):
+        obj = getattr(self, '_' + py_name)
+        typ = _str_to_class(self.__class__, typ_str)
+        if issubclass(typ, CrdObject) or issubclass(typ, CrdObjectList):
+            if nullable and obj is None:
+                return obj
+            if not required and obj is _omit:
+                return obj
+            return obj.to_json()
+        else:
+            return obj
+
+    def to_json(self):
+        # type: () -> Dict[str, Any]
+        res = {p[0]: self._property_to_json(*p) for p in self._properties}
+        res.update(self._additionalProperties)
+        return {k: v for k, v in res.items() if v is not _omit}
+
+    @classmethod
+    def from_json(cls, data, breadcrumb=''):
+        try:
+            sanitized = {
+                p[1]: _property_from_json(cls, data, breadcrumb, *p) for p in cls._properties
+            }
+            extra = {k:v for k,v in data.items() if k not in sanitized}
+            ret = cls(**sanitized)
+            ret._additionalProperties = {} if STRICT else extra
+            return ret
+        except (TypeError, AttributeError, KeyError):
+            logger.exception(breadcrumb)
+            raise
+
+
+class CrdClass(CrdObject):
+    @classmethod
+    def from_json(cls, data, breadcrumb=''):
+        kind = data['kind']
+        if kind != cls.__name__:
+            raise ValueError("kind mismatch: {} != {}".format(kind, cls.__name__))
+        return super(CrdClass, cls).from_json(data, breadcrumb)
+
+    def to_json(self):
+        ret = super(CrdClass, self).to_json()
+        ret['kind'] = self.__class__.__name__
+        return ret
+
+
+class CrdObjectList(list):
+    # Py3: Replace `Any` with `TypeVar('T_CrdObject', bound='CrdObject')`
+    _items_type = None  # type: Optional[Any]
+
+    def to_json(self):
+        # type: () -> List
+        if self._items_type is None:
+            return self
+        if issubclass(self._items_type, CrdObject) or issubclass(self._items_type, CrdObjectList):
+            return [e.to_json() for e in self]
+        return list(self)
+
+
+    @classmethod
+    def from_json(cls, data, breadcrumb=''):
+        if cls._items_type is None:
+            return cls(data)
+        if issubclass(cls._items_type, CrdObject) or issubclass(cls._items_type, CrdObjectList):
+<<<<<<< HEAD
+            return cls(cls._items_type.from_json(e, breadcrumb + '[]') for e in data)
+        return cls(data)
+
+    def __repr__(self):
+        return '{}({})'.format(self.__class__.__name__, repr(list(self)))
+=======
+            return cls(cls._items_type.from_json(e, breadcrumb + '[{}]'.format(i)) for i, e in enumerate(data))
+        return data
+>>>>>>> 2e4a0b5 (Better ex message for missing required elements)
+
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/cassandra/__init__.py b/src/pybind/mgr/rook/rook-client-python/rook_client/cassandra/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/cassandra/__init__.py
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/cassandra/cluster.py b/src/pybind/mgr/rook/rook-client-python/rook_client/cassandra/cluster.py
new file mode 100644
index 000000000..4fa3afc61
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/cassandra/cluster.py
@@ -0,0 +1,317 @@
+"""
+This file is automatically generated.
+Do not modify.
+"""
+
+try:
+    from typing import Any, Optional, Union, List
+except ImportError:
+    pass
+
+from .._helper import _omit, CrdObject, CrdObjectList, CrdClass
+
+class Storage(CrdObject):
+    _properties = [
+        ('volumeClaimTemplates', 'volumeClaimTemplates', object, True, False)
+    ]        
+
+    def __init__(self,
+                 volumeClaimTemplates,  # type: Any
+                 ):
+        super(Storage, self).__init__(
+            volumeClaimTemplates=volumeClaimTemplates,
+        )
+
+    @property
+    def volumeClaimTemplates(self):
+        # type: () -> Any
+        return self._property_impl('volumeClaimTemplates')
+    
+    @volumeClaimTemplates.setter
+    def volumeClaimTemplates(self, new_val):
+        # type: (Any) -> None
+        self._volumeClaimTemplates = new_val
+
+
+class Resources(CrdObject):
+    _properties = [
+        ('cassandra', 'cassandra', object, True, False),
+        ('sidecar', 'sidecar', object, True, False)
+    ]        
+
+    def __init__(self,
+                 cassandra,  # type: Any
+                 sidecar,  # type: Any
+                 ):
+        super(Resources, self).__init__(
+            cassandra=cassandra,
+            sidecar=sidecar,
+        )
+
+    @property
+    def cassandra(self):
+        # type: () -> Any
+        return self._property_impl('cassandra')
+    
+    @cassandra.setter
+    def cassandra(self, new_val):
+        # type: (Any) -> None
+        self._cassandra = new_val
+    
+    @property
+    def sidecar(self):
+        # type: () -> Any
+        return self._property_impl('sidecar')
+    
+    @sidecar.setter
+    def sidecar(self, new_val):
+        # type: (Any) -> None
+        self._sidecar = new_val
+
+
+class Racks(CrdObject):
+    _properties = [
+        ('name', 'name', str, True, False),
+        ('members', 'members', int, True, False),
+        ('configMapName', 'configMapName', str, False, False),
+        ('jmxExporterConfigMapName', 'jmxExporterConfigMapName', str, False, False),
+        ('storage', 'storage', Storage, True, False),
+        ('placement', 'placement', object, False, False),
+        ('resources', 'resources', Resources, True, False),
+        ('sidecarImage', 'sidecarImage', object, False, False)
+    ]        
+
+    def __init__(self,
+                 name,  # type: str
+                 members,  # type: int
+                 storage,  # type: Storage
+                 resources,  # type: Resources
+                 configMapName=_omit,  # type: Optional[str]
+                 jmxExporterConfigMapName=_omit,  # type: Optional[str]
+                 placement=_omit,  # type: Optional[Any]
+                 sidecarImage=_omit,  # type: Optional[Any]
+                 ):
+        super(Racks, self).__init__(
+            name=name,
+            members=members,
+            storage=storage,
+            resources=resources,
+            configMapName=configMapName,
+            jmxExporterConfigMapName=jmxExporterConfigMapName,
+            placement=placement,
+            sidecarImage=sidecarImage,
+        )
+
+    @property
+    def name(self):
+        # type: () -> str
+        return self._property_impl('name')
+    
+    @name.setter
+    def name(self, new_val):
+        # type: (str) -> None
+        self._name = new_val
+    
+    @property
+    def members(self):
+        # type: () -> int
+        return self._property_impl('members')
+    
+    @members.setter
+    def members(self, new_val):
+        # type: (int) -> None
+        self._members = new_val
+    
+    @property
+    def configMapName(self):
+        # type: () -> str
+        return self._property_impl('configMapName')
+    
+    @configMapName.setter
+    def configMapName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._configMapName = new_val
+    
+    @property
+    def jmxExporterConfigMapName(self):
+        # type: () -> str
+        return self._property_impl('jmxExporterConfigMapName')
+    
+    @jmxExporterConfigMapName.setter
+    def jmxExporterConfigMapName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._jmxExporterConfigMapName = new_val
+    
+    @property
+    def storage(self):
+        # type: () -> Storage
+        return self._property_impl('storage')
+    
+    @storage.setter
+    def storage(self, new_val):
+        # type: (Storage) -> None
+        self._storage = new_val
+    
+    @property
+    def placement(self):
+        # type: () -> Any
+        return self._property_impl('placement')
+    
+    @placement.setter
+    def placement(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._placement = new_val
+    
+    @property
+    def resources(self):
+        # type: () -> Resources
+        return self._property_impl('resources')
+    
+    @resources.setter
+    def resources(self, new_val):
+        # type: (Resources) -> None
+        self._resources = new_val
+    
+    @property
+    def sidecarImage(self):
+        # type: () -> Any
+        return self._property_impl('sidecarImage')
+    
+    @sidecarImage.setter
+    def sidecarImage(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._sidecarImage = new_val
+
+
+class Datacenter(CrdObject):
+    _properties = [
+        ('name', 'name', str, True, False),
+        ('racks', 'racks', Racks, False, False)
+    ]        
+
+    def __init__(self,
+                 name,  # type: str
+                 racks=_omit,  # type: Optional[Racks]
+                 ):
+        super(Datacenter, self).__init__(
+            name=name,
+            racks=racks,
+        )
+
+    @property
+    def name(self):
+        # type: () -> str
+        return self._property_impl('name')
+    
+    @name.setter
+    def name(self, new_val):
+        # type: (str) -> None
+        self._name = new_val
+    
+    @property
+    def racks(self):
+        # type: () -> Racks
+        return self._property_impl('racks')
+    
+    @racks.setter
+    def racks(self, new_val):
+        # type: (Optional[Racks]) -> None
+        self._racks = new_val
+
+
+class Spec(CrdObject):
+    _properties = [
+        ('version', 'version', str, True, False),
+        ('datacenter', 'datacenter', Datacenter, True, False)
+    ]        
+
+    def __init__(self,
+                 version,  # type: str
+                 datacenter,  # type: Datacenter
+                 ):
+        super(Spec, self).__init__(
+            version=version,
+            datacenter=datacenter,
+        )
+
+    @property
+    def version(self):
+        # type: () -> str
+        return self._property_impl('version')
+    
+    @version.setter
+    def version(self, new_val):
+        # type: (str) -> None
+        self._version = new_val
+    
+    @property
+    def datacenter(self):
+        # type: () -> Datacenter
+        return self._property_impl('datacenter')
+    
+    @datacenter.setter
+    def datacenter(self, new_val):
+        # type: (Datacenter) -> None
+        self._datacenter = new_val
+
+
+class Cluster(CrdClass):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, True, False),
+        ('metadata', 'metadata', object, True, False),
+        ('status', 'status', object, False, False),
+        ('spec', 'spec', Spec, True, False)
+    ]        
+
+    def __init__(self,
+                 apiVersion,  # type: str
+                 metadata,  # type: Any
+                 spec,  # type: Spec
+                 status=_omit,  # type: Optional[Any]
+                 ):
+        super(Cluster, self).__init__(
+            apiVersion=apiVersion,
+            metadata=metadata,
+            spec=spec,
+            status=status,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (str) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Any
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Any) -> None
+        self._metadata = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Any
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._status = new_val
+    
+    @property
+    def spec(self):
+        # type: () -> Spec
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Spec) -> None
+        self._spec = new_val
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/__init__.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/__init__.py
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephblockpool.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephblockpool.py
new file mode 100644
index 000000000..34e953eac
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephblockpool.py
@@ -0,0 +1,1193 @@
+"""
+This file is automatically generated.
+Do not modify.
+"""
+
+try:
+    from typing import Any, Optional, Union, List
+except ImportError:
+    pass
+
+from .._helper import _omit, CrdObject, CrdObjectList, CrdClass
+
+class ErasureCoded(CrdObject):
+    _properties = [
+        ('algorithm', 'algorithm', str, False, False),
+        ('codingChunks', 'codingChunks', int, True, False),
+        ('dataChunks', 'dataChunks', int, True, False)
+    ]        
+
+    def __init__(self,
+                 codingChunks,  # type: int
+                 dataChunks,  # type: int
+                 algorithm=_omit,  # type: Optional[str]
+                 ):
+        super(ErasureCoded, self).__init__(
+            codingChunks=codingChunks,
+            dataChunks=dataChunks,
+            algorithm=algorithm,
+        )
+
+    @property
+    def algorithm(self):
+        # type: () -> str
+        return self._property_impl('algorithm')
+    
+    @algorithm.setter
+    def algorithm(self, new_val):
+        # type: (Optional[str]) -> None
+        self._algorithm = new_val
+    
+    @property
+    def codingChunks(self):
+        # type: () -> int
+        return self._property_impl('codingChunks')
+    
+    @codingChunks.setter
+    def codingChunks(self, new_val):
+        # type: (int) -> None
+        self._codingChunks = new_val
+    
+    @property
+    def dataChunks(self):
+        # type: () -> int
+        return self._property_impl('dataChunks')
+    
+    @dataChunks.setter
+    def dataChunks(self, new_val):
+        # type: (int) -> None
+        self._dataChunks = new_val
+
+
+class SnapshotSchedulesItem(CrdObject):
+    _properties = [
+        ('image', 'image', str, False, False),
+        ('items', 'items', 'ItemsList', False, False),
+        ('namespace', 'namespace', str, False, False),
+        ('pool', 'pool', str, False, False),
+        ('interval', 'interval', str, False, False),
+        ('startTime', 'startTime', str, False, False)
+    ]        
+
+    def __init__(self,
+                 image=_omit,  # type: Optional[str]
+                 items=_omit,  # type: Optional[Union[List[ItemsItem], CrdObjectList]]
+                 namespace=_omit,  # type: Optional[str]
+                 pool=_omit,  # type: Optional[str]
+                 interval=_omit,  # type: Optional[str]
+                 startTime=_omit,  # type: Optional[str]
+                 ):
+        super(SnapshotSchedulesItem, self).__init__(
+            image=image,
+            items=items,
+            namespace=namespace,
+            pool=pool,
+            interval=interval,
+            startTime=startTime,
+        )
+
+    @property
+    def image(self):
+        # type: () -> str
+        return self._property_impl('image')
+    
+    @image.setter
+    def image(self, new_val):
+        # type: (Optional[str]) -> None
+        self._image = new_val
+    
+    @property
+    def items(self):
+        # type: () -> Union[List[ItemsItem], CrdObjectList]
+        return self._property_impl('items')
+    
+    @items.setter
+    def items(self, new_val):
+        # type: (Optional[Union[List[ItemsItem], CrdObjectList]]) -> None
+        self._items = new_val
+    
+    @property
+    def namespace(self):
+        # type: () -> str
+        return self._property_impl('namespace')
+    
+    @namespace.setter
+    def namespace(self, new_val):
+        # type: (Optional[str]) -> None
+        self._namespace = new_val
+    
+    @property
+    def pool(self):
+        # type: () -> str
+        return self._property_impl('pool')
+    
+    @pool.setter
+    def pool(self, new_val):
+        # type: (Optional[str]) -> None
+        self._pool = new_val
+    
+    @property
+    def interval(self):
+        # type: () -> str
+        return self._property_impl('interval')
+    
+    @interval.setter
+    def interval(self, new_val):
+        # type: (Optional[str]) -> None
+        self._interval = new_val
+    
+    @property
+    def startTime(self):
+        # type: () -> str
+        return self._property_impl('startTime')
+    
+    @startTime.setter
+    def startTime(self, new_val):
+        # type: (Optional[str]) -> None
+        self._startTime = new_val
+
+
+class SnapshotSchedulesList(CrdObjectList):
+    _items_type = SnapshotSchedulesItem
+
+
+class Mirroring(CrdObject):
+    _properties = [
+        ('enabled', 'enabled', bool, False, False),
+        ('mode', 'mode', str, False, False),
+        ('snapshotSchedules', 'snapshotSchedules', 'SnapshotSchedulesList', False, False)
+    ]        
+
+    def __init__(self,
+                 enabled=_omit,  # type: Optional[bool]
+                 mode=_omit,  # type: Optional[str]
+                 snapshotSchedules=_omit,  # type: Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]]
+                 ):
+        super(Mirroring, self).__init__(
+            enabled=enabled,
+            mode=mode,
+            snapshotSchedules=snapshotSchedules,
+        )
+
+    @property
+    def enabled(self):
+        # type: () -> bool
+        return self._property_impl('enabled')
+    
+    @enabled.setter
+    def enabled(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._enabled = new_val
+    
+    @property
+    def mode(self):
+        # type: () -> str
+        return self._property_impl('mode')
+    
+    @mode.setter
+    def mode(self, new_val):
+        # type: (Optional[str]) -> None
+        self._mode = new_val
+    
+    @property
+    def snapshotSchedules(self):
+        # type: () -> Union[List[SnapshotSchedulesItem], CrdObjectList]
+        return self._property_impl('snapshotSchedules')
+    
+    @snapshotSchedules.setter
+    def snapshotSchedules(self, new_val):
+        # type: (Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]]) -> None
+        self._snapshotSchedules = new_val
+
+
+class Quotas(CrdObject):
+    _properties = [
+        ('maxBytes', 'maxBytes', int, False, False),
+        ('maxObjects', 'maxObjects', int, False, False),
+        ('maxSize', 'maxSize', str, False, False)
+    ]        
+
+    def __init__(self,
+                 maxBytes=_omit,  # type: Optional[int]
+                 maxObjects=_omit,  # type: Optional[int]
+                 maxSize=_omit,  # type: Optional[str]
+                 ):
+        super(Quotas, self).__init__(
+            maxBytes=maxBytes,
+            maxObjects=maxObjects,
+            maxSize=maxSize,
+        )
+
+    @property
+    def maxBytes(self):
+        # type: () -> int
+        return self._property_impl('maxBytes')
+    
+    @maxBytes.setter
+    def maxBytes(self, new_val):
+        # type: (Optional[int]) -> None
+        self._maxBytes = new_val
+    
+    @property
+    def maxObjects(self):
+        # type: () -> int
+        return self._property_impl('maxObjects')
+    
+    @maxObjects.setter
+    def maxObjects(self, new_val):
+        # type: (Optional[int]) -> None
+        self._maxObjects = new_val
+    
+    @property
+    def maxSize(self):
+        # type: () -> str
+        return self._property_impl('maxSize')
+    
+    @maxSize.setter
+    def maxSize(self, new_val):
+        # type: (Optional[str]) -> None
+        self._maxSize = new_val
+
+
+class Replicated(CrdObject):
+    _properties = [
+        ('replicasPerFailureDomain', 'replicasPerFailureDomain', int, False, False),
+        ('requireSafeReplicaSize', 'requireSafeReplicaSize', bool, False, False),
+        ('size', 'size', int, True, False),
+        ('subFailureDomain', 'subFailureDomain', str, False, False),
+        ('targetSizeRatio', 'targetSizeRatio', float, False, False)
+    ]        
+
+    def __init__(self,
+                 size,  # type: int
+                 replicasPerFailureDomain=_omit,  # type: Optional[int]
+                 requireSafeReplicaSize=_omit,  # type: Optional[bool]
+                 subFailureDomain=_omit,  # type: Optional[str]
+                 targetSizeRatio=_omit,  # type: Optional[float]
+                 ):
+        super(Replicated, self).__init__(
+            size=size,
+            replicasPerFailureDomain=replicasPerFailureDomain,
+            requireSafeReplicaSize=requireSafeReplicaSize,
+            subFailureDomain=subFailureDomain,
+            targetSizeRatio=targetSizeRatio,
+        )
+
+    @property
+    def replicasPerFailureDomain(self):
+        # type: () -> int
+        return self._property_impl('replicasPerFailureDomain')
+    
+    @replicasPerFailureDomain.setter
+    def replicasPerFailureDomain(self, new_val):
+        # type: (Optional[int]) -> None
+        self._replicasPerFailureDomain = new_val
+    
+    @property
+    def requireSafeReplicaSize(self):
+        # type: () -> bool
+        return self._property_impl('requireSafeReplicaSize')
+    
+    @requireSafeReplicaSize.setter
+    def requireSafeReplicaSize(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._requireSafeReplicaSize = new_val
+    
+    @property
+    def size(self):
+        # type: () -> int
+        return self._property_impl('size')
+    
+    @size.setter
+    def size(self, new_val):
+        # type: (int) -> None
+        self._size = new_val
+    
+    @property
+    def subFailureDomain(self):
+        # type: () -> str
+        return self._property_impl('subFailureDomain')
+    
+    @subFailureDomain.setter
+    def subFailureDomain(self, new_val):
+        # type: (Optional[str]) -> None
+        self._subFailureDomain = new_val
+    
+    @property
+    def targetSizeRatio(self):
+        # type: () -> float
+        return self._property_impl('targetSizeRatio')
+    
+    @targetSizeRatio.setter
+    def targetSizeRatio(self, new_val):
+        # type: (Optional[float]) -> None
+        self._targetSizeRatio = new_val
+
+
+class Mirror(CrdObject):
+    _properties = [
+        ('disabled', 'disabled', bool, False, False),
+        ('interval', 'interval', str, False, False),
+        ('timeout', 'timeout', str, False, False)
+    ]        
+
+    def __init__(self,
+                 disabled=_omit,  # type: Optional[bool]
+                 interval=_omit,  # type: Optional[str]
+                 timeout=_omit,  # type: Optional[str]
+                 ):
+        super(Mirror, self).__init__(
+            disabled=disabled,
+            interval=interval,
+            timeout=timeout,
+        )
+
+    @property
+    def disabled(self):
+        # type: () -> bool
+        return self._property_impl('disabled')
+    
+    @disabled.setter
+    def disabled(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._disabled = new_val
+    
+    @property
+    def interval(self):
+        # type: () -> str
+        return self._property_impl('interval')
+    
+    @interval.setter
+    def interval(self, new_val):
+        # type: (Optional[str]) -> None
+        self._interval = new_val
+    
+    @property
+    def timeout(self):
+        # type: () -> str
+        return self._property_impl('timeout')
+    
+    @timeout.setter
+    def timeout(self, new_val):
+        # type: (Optional[str]) -> None
+        self._timeout = new_val
+
+
+class StatusCheck(CrdObject):
+    _properties = [
+        ('mirror', 'mirror', 'Mirror', False, True)
+    ]        
+
+    def __init__(self,
+                 mirror=_omit,  # type: Optional[Mirror]
+                 ):
+        super(StatusCheck, self).__init__(
+            mirror=mirror,
+        )
+
+    @property
+    def mirror(self):
+        # type: () -> Optional[Mirror]
+        return self._property_impl('mirror')
+    
+    @mirror.setter
+    def mirror(self, new_val):
+        # type: (Optional[Mirror]) -> None
+        self._mirror = new_val
+
+
+class Spec(CrdObject):
+    _properties = [
+        ('compressionMode', 'compressionMode', str, False, True),
+        ('crushRoot', 'crushRoot', str, False, True),
+        ('deviceClass', 'deviceClass', str, False, True),
+        ('enableRBDStats', 'enableRBDStats', bool, False, False),
+        ('erasureCoded', 'erasureCoded', 'ErasureCoded', False, False),
+        ('failureDomain', 'failureDomain', str, False, False),
+        ('mirroring', 'mirroring', 'Mirroring', False, False),
+        ('parameters', 'parameters', object, False, True),
+        ('quotas', 'quotas', 'Quotas', False, True),
+        ('replicated', 'replicated', 'Replicated', False, False),
+        ('statusCheck', 'statusCheck', 'StatusCheck', False, False)
+    ]        
+
+    def __init__(self,
+                 compressionMode=_omit,  # type: Optional[str]
+                 crushRoot=_omit,  # type: Optional[str]
+                 deviceClass=_omit,  # type: Optional[str]
+                 enableRBDStats=_omit,  # type: Optional[bool]
+                 erasureCoded=_omit,  # type: Optional[ErasureCoded]
+                 failureDomain=_omit,  # type: Optional[str]
+                 mirroring=_omit,  # type: Optional[Mirroring]
+                 parameters=_omit,  # type: Optional[Any]
+                 quotas=_omit,  # type: Optional[Quotas]
+                 replicated=_omit,  # type: Optional[Replicated]
+                 statusCheck=_omit,  # type: Optional[StatusCheck]
+                 ):
+        super(Spec, self).__init__(
+            compressionMode=compressionMode,
+            crushRoot=crushRoot,
+            deviceClass=deviceClass,
+            enableRBDStats=enableRBDStats,
+            erasureCoded=erasureCoded,
+            failureDomain=failureDomain,
+            mirroring=mirroring,
+            parameters=parameters,
+            quotas=quotas,
+            replicated=replicated,
+            statusCheck=statusCheck,
+        )
+
+    @property
+    def compressionMode(self):
+        # type: () -> Optional[str]
+        return self._property_impl('compressionMode')
+    
+    @compressionMode.setter
+    def compressionMode(self, new_val):
+        # type: (Optional[str]) -> None
+        self._compressionMode = new_val
+    
+    @property
+    def crushRoot(self):
+        # type: () -> Optional[str]
+        return self._property_impl('crushRoot')
+    
+    @crushRoot.setter
+    def crushRoot(self, new_val):
+        # type: (Optional[str]) -> None
+        self._crushRoot = new_val
+    
+    @property
+    def deviceClass(self):
+        # type: () -> Optional[str]
+        return self._property_impl('deviceClass')
+    
+    @deviceClass.setter
+    def deviceClass(self, new_val):
+        # type: (Optional[str]) -> None
+        self._deviceClass = new_val
+    
+    @property
+    def enableRBDStats(self):
+        # type: () -> bool
+        return self._property_impl('enableRBDStats')
+    
+    @enableRBDStats.setter
+    def enableRBDStats(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._enableRBDStats = new_val
+    
+    @property
+    def erasureCoded(self):
+        # type: () -> ErasureCoded
+        return self._property_impl('erasureCoded')
+    
+    @erasureCoded.setter
+    def erasureCoded(self, new_val):
+        # type: (Optional[ErasureCoded]) -> None
+        self._erasureCoded = new_val
+    
+    @property
+    def failureDomain(self):
+        # type: () -> str
+        return self._property_impl('failureDomain')
+    
+    @failureDomain.setter
+    def failureDomain(self, new_val):
+        # type: (Optional[str]) -> None
+        self._failureDomain = new_val
+    
+    @property
+    def mirroring(self):
+        # type: () -> Mirroring
+        return self._property_impl('mirroring')
+    
+    @mirroring.setter
+    def mirroring(self, new_val):
+        # type: (Optional[Mirroring]) -> None
+        self._mirroring = new_val
+    
+    @property
+    def parameters(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('parameters')
+    
+    @parameters.setter
+    def parameters(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._parameters = new_val
+    
+    @property
+    def quotas(self):
+        # type: () -> Optional[Quotas]
+        return self._property_impl('quotas')
+    
+    @quotas.setter
+    def quotas(self, new_val):
+        # type: (Optional[Quotas]) -> None
+        self._quotas = new_val
+    
+    @property
+    def replicated(self):
+        # type: () -> Replicated
+        return self._property_impl('replicated')
+    
+    @replicated.setter
+    def replicated(self, new_val):
+        # type: (Optional[Replicated]) -> None
+        self._replicated = new_val
+    
+    @property
+    def statusCheck(self):
+        # type: () -> StatusCheck
+        return self._property_impl('statusCheck')
+    
+    @statusCheck.setter
+    def statusCheck(self, new_val):
+        # type: (Optional[StatusCheck]) -> None
+        self._statusCheck = new_val
+
+
+class PeersItem(CrdObject):
+    _properties = [
+        ('client_name', 'client_name', str, False, False),
+        ('direction', 'direction', str, False, False),
+        ('mirror_uuid', 'mirror_uuid', str, False, False),
+        ('site_name', 'site_name', str, False, False),
+        ('uuid', 'uuid', str, False, False)
+    ]        
+
+    def __init__(self,
+                 client_name=_omit,  # type: Optional[str]
+                 direction=_omit,  # type: Optional[str]
+                 mirror_uuid=_omit,  # type: Optional[str]
+                 site_name=_omit,  # type: Optional[str]
+                 uuid=_omit,  # type: Optional[str]
+                 ):
+        super(PeersItem, self).__init__(
+            client_name=client_name,
+            direction=direction,
+            mirror_uuid=mirror_uuid,
+            site_name=site_name,
+            uuid=uuid,
+        )
+
+    @property
+    def client_name(self):
+        # type: () -> str
+        return self._property_impl('client_name')
+    
+    @client_name.setter
+    def client_name(self, new_val):
+        # type: (Optional[str]) -> None
+        self._client_name = new_val
+    
+    @property
+    def direction(self):
+        # type: () -> str
+        return self._property_impl('direction')
+    
+    @direction.setter
+    def direction(self, new_val):
+        # type: (Optional[str]) -> None
+        self._direction = new_val
+    
+    @property
+    def mirror_uuid(self):
+        # type: () -> str
+        return self._property_impl('mirror_uuid')
+    
+    @mirror_uuid.setter
+    def mirror_uuid(self, new_val):
+        # type: (Optional[str]) -> None
+        self._mirror_uuid = new_val
+    
+    @property
+    def site_name(self):
+        # type: () -> str
+        return self._property_impl('site_name')
+    
+    @site_name.setter
+    def site_name(self, new_val):
+        # type: (Optional[str]) -> None
+        self._site_name = new_val
+    
+    @property
+    def uuid(self):
+        # type: () -> str
+        return self._property_impl('uuid')
+    
+    @uuid.setter
+    def uuid(self, new_val):
+        # type: (Optional[str]) -> None
+        self._uuid = new_val
+
+
+class PeersList(CrdObjectList):
+    _items_type = PeersItem
+
+
+class MirroringInfo(CrdObject):
+    _properties = [
+        ('details', 'details', str, False, False),
+        ('lastChanged', 'lastChanged', str, False, False),
+        ('lastChecked', 'lastChecked', str, False, False),
+        ('mode', 'mode', str, False, False),
+        ('peers', 'peers', 'PeersList', False, False),
+        ('site_name', 'site_name', str, False, False)
+    ]        
+
+    def __init__(self,
+                 details=_omit,  # type: Optional[str]
+                 lastChanged=_omit,  # type: Optional[str]
+                 lastChecked=_omit,  # type: Optional[str]
+                 mode=_omit,  # type: Optional[str]
+                 peers=_omit,  # type: Optional[Union[List[PeersItem], CrdObjectList]]
+                 site_name=_omit,  # type: Optional[str]
+                 ):
+        super(MirroringInfo, self).__init__(
+            details=details,
+            lastChanged=lastChanged,
+            lastChecked=lastChecked,
+            mode=mode,
+            peers=peers,
+            site_name=site_name,
+        )
+
+    @property
+    def details(self):
+        # type: () -> str
+        return self._property_impl('details')
+    
+    @details.setter
+    def details(self, new_val):
+        # type: (Optional[str]) -> None
+        self._details = new_val
+    
+    @property
+    def lastChanged(self):
+        # type: () -> str
+        return self._property_impl('lastChanged')
+    
+    @lastChanged.setter
+    def lastChanged(self, new_val):
+        # type: (Optional[str]) -> None
+        self._lastChanged = new_val
+    
+    @property
+    def lastChecked(self):
+        # type: () -> str
+        return self._property_impl('lastChecked')
+    
+    @lastChecked.setter
+    def lastChecked(self, new_val):
+        # type: (Optional[str]) -> None
+        self._lastChecked = new_val
+    
+    @property
+    def mode(self):
+        # type: () -> str
+        return self._property_impl('mode')
+    
+    @mode.setter
+    def mode(self, new_val):
+        # type: (Optional[str]) -> None
+        self._mode = new_val
+    
+    @property
+    def peers(self):
+        # type: () -> Union[List[PeersItem], CrdObjectList]
+        return self._property_impl('peers')
+    
+    @peers.setter
+    def peers(self, new_val):
+        # type: (Optional[Union[List[PeersItem], CrdObjectList]]) -> None
+        self._peers = new_val
+    
+    @property
+    def site_name(self):
+        # type: () -> str
+        return self._property_impl('site_name')
+    
+    @site_name.setter
+    def site_name(self, new_val):
+        # type: (Optional[str]) -> None
+        self._site_name = new_val
+
+
+class States(CrdObject):
+    _properties = [
+        ('error', 'error', int, False, False),
+        ('replaying', 'replaying', int, False, False),
+        ('starting_replay', 'starting_replay', int, False, False),
+        ('stopped', 'stopped', int, False, False),
+        ('stopping_replay', 'stopping_replay', int, False, False),
+        ('syncing', 'syncing', int, False, False),
+        ('unknown', 'unknown', int, False, False)
+    ]        
+
+    def __init__(self,
+                 error=_omit,  # type: Optional[int]
+                 replaying=_omit,  # type: Optional[int]
+                 starting_replay=_omit,  # type: Optional[int]
+                 stopped=_omit,  # type: Optional[int]
+                 stopping_replay=_omit,  # type: Optional[int]
+                 syncing=_omit,  # type: Optional[int]
+                 unknown=_omit,  # type: Optional[int]
+                 ):
+        super(States, self).__init__(
+            error=error,
+            replaying=replaying,
+            starting_replay=starting_replay,
+            stopped=stopped,
+            stopping_replay=stopping_replay,
+            syncing=syncing,
+            unknown=unknown,
+        )
+
+    @property
+    def error(self):
+        # type: () -> int
+        return self._property_impl('error')
+    
+    @error.setter
+    def error(self, new_val):
+        # type: (Optional[int]) -> None
+        self._error = new_val
+    
+    @property
+    def replaying(self):
+        # type: () -> int
+        return self._property_impl('replaying')
+    
+    @replaying.setter
+    def replaying(self, new_val):
+        # type: (Optional[int]) -> None
+        self._replaying = new_val
+    
+    @property
+    def starting_replay(self):
+        # type: () -> int
+        return self._property_impl('starting_replay')
+    
+    @starting_replay.setter
+    def starting_replay(self, new_val):
+        # type: (Optional[int]) -> None
+        self._starting_replay = new_val
+    
+    @property
+    def stopped(self):
+        # type: () -> int
+        return self._property_impl('stopped')
+    
+    @stopped.setter
+    def stopped(self, new_val):
+        # type: (Optional[int]) -> None
+        self._stopped = new_val
+    
+    @property
+    def stopping_replay(self):
+        # type: () -> int
+        return self._property_impl('stopping_replay')
+    
+    @stopping_replay.setter
+    def stopping_replay(self, new_val):
+        # type: (Optional[int]) -> None
+        self._stopping_replay = new_val
+    
+    @property
+    def syncing(self):
+        # type: () -> int
+        return self._property_impl('syncing')
+    
+    @syncing.setter
+    def syncing(self, new_val):
+        # type: (Optional[int]) -> None
+        self._syncing = new_val
+    
+    @property
+    def unknown(self):
+        # type: () -> int
+        return self._property_impl('unknown')
+    
+    @unknown.setter
+    def unknown(self, new_val):
+        # type: (Optional[int]) -> None
+        self._unknown = new_val
+
+
+class Summary(CrdObject):
+    _properties = [
+        ('daemon_health', 'daemon_health', str, False, False),
+        ('health', 'health', str, False, False),
+        ('image_health', 'image_health', str, False, False),
+        ('states', 'states', 'States', False, True)
+    ]        
+
+    def __init__(self,
+                 daemon_health=_omit,  # type: Optional[str]
+                 health=_omit,  # type: Optional[str]
+                 image_health=_omit,  # type: Optional[str]
+                 states=_omit,  # type: Optional[States]
+                 ):
+        super(Summary, self).__init__(
+            daemon_health=daemon_health,
+            health=health,
+            image_health=image_health,
+            states=states,
+        )
+
+    @property
+    def daemon_health(self):
+        # type: () -> str
+        return self._property_impl('daemon_health')
+    
+    @daemon_health.setter
+    def daemon_health(self, new_val):
+        # type: (Optional[str]) -> None
+        self._daemon_health = new_val
+    
+    @property
+    def health(self):
+        # type: () -> str
+        return self._property_impl('health')
+    
+    @health.setter
+    def health(self, new_val):
+        # type: (Optional[str]) -> None
+        self._health = new_val
+    
+    @property
+    def image_health(self):
+        # type: () -> str
+        return self._property_impl('image_health')
+    
+    @image_health.setter
+    def image_health(self, new_val):
+        # type: (Optional[str]) -> None
+        self._image_health = new_val
+    
+    @property
+    def states(self):
+        # type: () -> Optional[States]
+        return self._property_impl('states')
+    
+    @states.setter
+    def states(self, new_val):
+        # type: (Optional[States]) -> None
+        self._states = new_val
+
+
+class MirroringStatus(CrdObject):
+    _properties = [
+        ('details', 'details', str, False, False),
+        ('lastChanged', 'lastChanged', str, False, False),
+        ('lastChecked', 'lastChecked', str, False, False),
+        ('summary', 'summary', 'Summary', False, False)
+    ]        
+
+    def __init__(self,
+                 details=_omit,  # type: Optional[str]
+                 lastChanged=_omit,  # type: Optional[str]
+                 lastChecked=_omit,  # type: Optional[str]
+                 summary=_omit,  # type: Optional[Summary]
+                 ):
+        super(MirroringStatus, self).__init__(
+            details=details,
+            lastChanged=lastChanged,
+            lastChecked=lastChecked,
+            summary=summary,
+        )
+
+    @property
+    def details(self):
+        # type: () -> str
+        return self._property_impl('details')
+    
+    @details.setter
+    def details(self, new_val):
+        # type: (Optional[str]) -> None
+        self._details = new_val
+    
+    @property
+    def lastChanged(self):
+        # type: () -> str
+        return self._property_impl('lastChanged')
+    
+    @lastChanged.setter
+    def lastChanged(self, new_val):
+        # type: (Optional[str]) -> None
+        self._lastChanged = new_val
+    
+    @property
+    def lastChecked(self):
+        # type: () -> str
+        return self._property_impl('lastChecked')
+    
+    @lastChecked.setter
+    def lastChecked(self, new_val):
+        # type: (Optional[str]) -> None
+        self._lastChecked = new_val
+    
+    @property
+    def summary(self):
+        # type: () -> Summary
+        return self._property_impl('summary')
+    
+    @summary.setter
+    def summary(self, new_val):
+        # type: (Optional[Summary]) -> None
+        self._summary = new_val
+
+
+class ItemsItem(CrdObject):
+    _properties = [
+        ('interval', 'interval', str, False, False),
+        ('start_time', 'start_time', str, False, False)
+    ]        
+
+    def __init__(self,
+                 interval=_omit,  # type: Optional[str]
+                 start_time=_omit,  # type: Optional[str]
+                 ):
+        super(ItemsItem, self).__init__(
+            interval=interval,
+            start_time=start_time,
+        )
+
+    @property
+    def interval(self):
+        # type: () -> str
+        return self._property_impl('interval')
+    
+    @interval.setter
+    def interval(self, new_val):
+        # type: (Optional[str]) -> None
+        self._interval = new_val
+    
+    @property
+    def start_time(self):
+        # type: () -> str
+        return self._property_impl('start_time')
+    
+    @start_time.setter
+    def start_time(self, new_val):
+        # type: (Optional[str]) -> None
+        self._start_time = new_val
+
+
+class ItemsList(CrdObjectList):
+    _items_type = ItemsItem
+
+
+class SnapshotScheduleStatus(CrdObject):
+    _properties = [
+        ('details', 'details', str, False, False),
+        ('lastChanged', 'lastChanged', str, False, False),
+        ('lastChecked', 'lastChecked', str, False, False),
+        ('snapshotSchedules', 'snapshotSchedules', 'SnapshotSchedulesList', False, True)
+    ]        
+
+    def __init__(self,
+                 details=_omit,  # type: Optional[str]
+                 lastChanged=_omit,  # type: Optional[str]
+                 lastChecked=_omit,  # type: Optional[str]
+                 snapshotSchedules=_omit,  # type: Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]]
+                 ):
+        super(SnapshotScheduleStatus, self).__init__(
+            details=details,
+            lastChanged=lastChanged,
+            lastChecked=lastChecked,
+            snapshotSchedules=snapshotSchedules,
+        )
+
+    @property
+    def details(self):
+        # type: () -> str
+        return self._property_impl('details')
+    
+    @details.setter
+    def details(self, new_val):
+        # type: (Optional[str]) -> None
+        self._details = new_val
+    
+    @property
+    def lastChanged(self):
+        # type: () -> str
+        return self._property_impl('lastChanged')
+    
+    @lastChanged.setter
+    def lastChanged(self, new_val):
+        # type: (Optional[str]) -> None
+        self._lastChanged = new_val
+    
+    @property
+    def lastChecked(self):
+        # type: () -> str
+        return self._property_impl('lastChecked')
+    
+    @lastChecked.setter
+    def lastChecked(self, new_val):
+        # type: (Optional[str]) -> None
+        self._lastChecked = new_val
+    
+    @property
+    def snapshotSchedules(self):
+        # type: () -> Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]]
+        return self._property_impl('snapshotSchedules')
+    
+    @snapshotSchedules.setter
+    def snapshotSchedules(self, new_val):
+        # type: (Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]]) -> None
+        self._snapshotSchedules = new_val
+
+
+class Status(CrdObject):
+    _properties = [
+        ('info', 'info', object, False, True),
+        ('mirroringInfo', 'mirroringInfo', 'MirroringInfo', False, False),
+        ('mirroringStatus', 'mirroringStatus', 'MirroringStatus', False, False),
+        ('phase', 'phase', str, False, False),
+        ('snapshotScheduleStatus', 'snapshotScheduleStatus', 'SnapshotScheduleStatus', False, False)
+    ]        
+
+    def __init__(self,
+                 info=_omit,  # type: Optional[Any]
+                 mirroringInfo=_omit,  # type: Optional[MirroringInfo]
+                 mirroringStatus=_omit,  # type: Optional[MirroringStatus]
+                 phase=_omit,  # type: Optional[str]
+                 snapshotScheduleStatus=_omit,  # type: Optional[SnapshotScheduleStatus]
+                 ):
+        super(Status, self).__init__(
+            info=info,
+            mirroringInfo=mirroringInfo,
+            mirroringStatus=mirroringStatus,
+            phase=phase,
+            snapshotScheduleStatus=snapshotScheduleStatus,
+        )
+
+    @property
+    def info(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('info')
+    
+    @info.setter
+    def info(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._info = new_val
+    
+    @property
+    def mirroringInfo(self):
+        # type: () -> MirroringInfo
+        return self._property_impl('mirroringInfo')
+    
+    @mirroringInfo.setter
+    def mirroringInfo(self, new_val):
+        # type: (Optional[MirroringInfo]) -> None
+        self._mirroringInfo = new_val
+    
+    @property
+    def mirroringStatus(self):
+        # type: () -> MirroringStatus
+        return self._property_impl('mirroringStatus')
+    
+    @mirroringStatus.setter
+    def mirroringStatus(self, new_val):
+        # type: (Optional[MirroringStatus]) -> None
+        self._mirroringStatus = new_val
+    
+    @property
+    def phase(self):
+        # type: () -> str
+        return self._property_impl('phase')
+    
+    @phase.setter
+    def phase(self, new_val):
+        # type: (Optional[str]) -> None
+        self._phase = new_val
+    
+    @property
+    def snapshotScheduleStatus(self):
+        # type: () -> SnapshotScheduleStatus
+        return self._property_impl('snapshotScheduleStatus')
+    
+    @snapshotScheduleStatus.setter
+    def snapshotScheduleStatus(self, new_val):
+        # type: (Optional[SnapshotScheduleStatus]) -> None
+        self._snapshotScheduleStatus = new_val
+
+
+class CephBlockPool(CrdClass):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('kind', 'kind', str, False, False),
+        ('metadata', 'metadata', object, False, False),
+        ('spec', 'spec', 'Spec', True, False),
+        ('status', 'status', 'Status', False, False)
+    ]        
+
+    def __init__(self,
+                 spec,  # type: Spec
+                 apiVersion=_omit,  # type: Optional[str]
+                 kind=_omit,  # type: Optional[str]
+                 metadata=_omit,  # type: Optional[Any]
+                 status=_omit,  # type: Optional[Status]
+                 ):
+        super(CephBlockPool, self).__init__(
+            spec=spec,
+            apiVersion=apiVersion,
+            kind=kind,
+            metadata=metadata,
+            status=status,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Any
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._metadata = new_val
+    
+    @property
+    def spec(self):
+        # type: () -> Spec
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Spec) -> None
+        self._spec = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Status
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Status]) -> None
+        self._status = new_val
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephclient.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephclient.py
new file mode 100644
index 000000000..c7f8c7863
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephclient.py
@@ -0,0 +1,157 @@
+"""
+This file is automatically generated.
+Do not modify.
+"""
+
+try:
+    from typing import Any, Optional, Union, List
+except ImportError:
+    pass
+
+from .._helper import _omit, CrdObject, CrdObjectList, CrdClass
+
+class Spec(CrdObject):
+    _properties = [
+        ('caps', 'caps', object, True, False),
+        ('name', 'name', str, False, False)
+    ]        
+
+    def __init__(self,
+                 caps,  # type: Any
+                 name=_omit,  # type: Optional[str]
+                 ):
+        super(Spec, self).__init__(
+            caps=caps,
+            name=name,
+        )
+
+    @property
+    def caps(self):
+        # type: () -> Any
+        return self._property_impl('caps')
+    
+    @caps.setter
+    def caps(self, new_val):
+        # type: (Any) -> None
+        self._caps = new_val
+    
+    @property
+    def name(self):
+        # type: () -> str
+        return self._property_impl('name')
+    
+    @name.setter
+    def name(self, new_val):
+        # type: (Optional[str]) -> None
+        self._name = new_val
+
+
+class Status(CrdObject):
+    _properties = [
+        ('info', 'info', object, False, True),
+        ('phase', 'phase', str, False, False)
+    ]        
+
+    def __init__(self,
+                 info=_omit,  # type: Optional[Any]
+                 phase=_omit,  # type: Optional[str]
+                 ):
+        super(Status, self).__init__(
+            info=info,
+            phase=phase,
+        )
+
+    @property
+    def info(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('info')
+    
+    @info.setter
+    def info(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._info = new_val
+    
+    @property
+    def phase(self):
+        # type: () -> str
+        return self._property_impl('phase')
+    
+    @phase.setter
+    def phase(self, new_val):
+        # type: (Optional[str]) -> None
+        self._phase = new_val
+
+
+class CephClient(CrdClass):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('kind', 'kind', str, False, False),
+        ('metadata', 'metadata', object, False, False),
+        ('spec', 'spec', 'Spec', True, False),
+        ('status', 'status', 'Status', False, False)
+    ]        
+
+    def __init__(self,
+                 spec,  # type: Spec
+                 apiVersion=_omit,  # type: Optional[str]
+                 kind=_omit,  # type: Optional[str]
+                 metadata=_omit,  # type: Optional[Any]
+                 status=_omit,  # type: Optional[Status]
+                 ):
+        super(CephClient, self).__init__(
+            spec=spec,
+            apiVersion=apiVersion,
+            kind=kind,
+            metadata=metadata,
+            status=status,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Any
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._metadata = new_val
+    
+    @property
+    def spec(self):
+        # type: () -> Spec
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Spec) -> None
+        self._spec = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Status
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Status]) -> None
+        self._status = new_val
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephcluster.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephcluster.py
new file mode 100644
index 000000000..00cdbc817
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephcluster.py
@@ -0,0 +1,3959 @@
+"""
+This file is automatically generated.
+Do not modify.
+"""
+
+try:
+    from typing import Any, Optional, Union, List
+except ImportError:
+    pass
+
+from .._helper import _omit, CrdObject, CrdObjectList, CrdClass
+
+class CephVersion(CrdObject):
+    _properties = [
+        ('allowUnsupported', 'allowUnsupported', bool, False, False),
+        ('image', 'image', str, False, False)
+    ]        
+
+    def __init__(self,
+                 allowUnsupported=_omit,  # type: Optional[bool]
+                 image=_omit,  # type: Optional[str]
+                 ):
+        super(CephVersion, self).__init__(
+            allowUnsupported=allowUnsupported,
+            image=image,
+        )
+
+    @property
+    def allowUnsupported(self):
+        # type: () -> bool
+        return self._property_impl('allowUnsupported')
+    
+    @allowUnsupported.setter
+    def allowUnsupported(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._allowUnsupported = new_val
+    
+    @property
+    def image(self):
+        # type: () -> str
+        return self._property_impl('image')
+    
+    @image.setter
+    def image(self, new_val):
+        # type: (Optional[str]) -> None
+        self._image = new_val
+
+
+class SanitizeDisks(CrdObject):
+    _properties = [
+        ('dataSource', 'dataSource', str, False, False),
+        ('iteration', 'iteration', int, False, False),
+        ('method', 'method', str, False, False)
+    ]        
+
+    def __init__(self,
+                 dataSource=_omit,  # type: Optional[str]
+                 iteration=_omit,  # type: Optional[int]
+                 method=_omit,  # type: Optional[str]
+                 ):
+        super(SanitizeDisks, self).__init__(
+            dataSource=dataSource,
+            iteration=iteration,
+            method=method,
+        )
+
+    @property
+    def dataSource(self):
+        # type: () -> str
+        return self._property_impl('dataSource')
+    
+    @dataSource.setter
+    def dataSource(self, new_val):
+        # type: (Optional[str]) -> None
+        self._dataSource = new_val
+    
+    @property
+    def iteration(self):
+        # type: () -> int
+        return self._property_impl('iteration')
+    
+    @iteration.setter
+    def iteration(self, new_val):
+        # type: (Optional[int]) -> None
+        self._iteration = new_val
+    
+    @property
+    def method(self):
+        # type: () -> str
+        return self._property_impl('method')
+    
+    @method.setter
+    def method(self, new_val):
+        # type: (Optional[str]) -> None
+        self._method = new_val
+
+
+class CleanupPolicy(CrdObject):
+    _properties = [
+        ('allowUninstallWithVolumes', 'allowUninstallWithVolumes', bool, False, False),
+        ('confirmation', 'confirmation', str, False, True),
+        ('sanitizeDisks', 'sanitizeDisks', 'SanitizeDisks', False, True)
+    ]        
+
+    def __init__(self,
+                 allowUninstallWithVolumes=_omit,  # type: Optional[bool]
+                 confirmation=_omit,  # type: Optional[str]
+                 sanitizeDisks=_omit,  # type: Optional[SanitizeDisks]
+                 ):
+        super(CleanupPolicy, self).__init__(
+            allowUninstallWithVolumes=allowUninstallWithVolumes,
+            confirmation=confirmation,
+            sanitizeDisks=sanitizeDisks,
+        )
+
+    @property
+    def allowUninstallWithVolumes(self):
+        # type: () -> bool
+        return self._property_impl('allowUninstallWithVolumes')
+    
+    @allowUninstallWithVolumes.setter
+    def allowUninstallWithVolumes(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._allowUninstallWithVolumes = new_val
+    
+    @property
+    def confirmation(self):
+        # type: () -> Optional[str]
+        return self._property_impl('confirmation')
+    
+    @confirmation.setter
+    def confirmation(self, new_val):
+        # type: (Optional[str]) -> None
+        self._confirmation = new_val
+    
+    @property
+    def sanitizeDisks(self):
+        # type: () -> Optional[SanitizeDisks]
+        return self._property_impl('sanitizeDisks')
+    
+    @sanitizeDisks.setter
+    def sanitizeDisks(self, new_val):
+        # type: (Optional[SanitizeDisks]) -> None
+        self._sanitizeDisks = new_val
+
+
+class CrashCollector(CrdObject):
+    _properties = [
+        ('daysToRetain', 'daysToRetain', int, False, False),
+        ('disable', 'disable', bool, False, False)
+    ]        
+
+    def __init__(self,
+                 daysToRetain=_omit,  # type: Optional[int]
+                 disable=_omit,  # type: Optional[bool]
+                 ):
+        super(CrashCollector, self).__init__(
+            daysToRetain=daysToRetain,
+            disable=disable,
+        )
+
+    @property
+    def daysToRetain(self):
+        # type: () -> int
+        return self._property_impl('daysToRetain')
+    
+    @daysToRetain.setter
+    def daysToRetain(self, new_val):
+        # type: (Optional[int]) -> None
+        self._daysToRetain = new_val
+    
+    @property
+    def disable(self):
+        # type: () -> bool
+        return self._property_impl('disable')
+    
+    @disable.setter
+    def disable(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._disable = new_val
+
+
+class Dashboard(CrdObject):
+    _properties = [
+        ('enabled', 'enabled', bool, False, False),
+        ('port', 'port', int, False, False),
+        ('ssl', 'ssl', bool, False, False),
+        ('urlPrefix', 'urlPrefix', str, False, False)
+    ]        
+
+    def __init__(self,
+                 enabled=_omit,  # type: Optional[bool]
+                 port=_omit,  # type: Optional[int]
+                 ssl=_omit,  # type: Optional[bool]
+                 urlPrefix=_omit,  # type: Optional[str]
+                 ):
+        super(Dashboard, self).__init__(
+            enabled=enabled,
+            port=port,
+            ssl=ssl,
+            urlPrefix=urlPrefix,
+        )
+
+    @property
+    def enabled(self):
+        # type: () -> bool
+        return self._property_impl('enabled')
+    
+    @enabled.setter
+    def enabled(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._enabled = new_val
+    
+    @property
+    def port(self):
+        # type: () -> int
+        return self._property_impl('port')
+    
+    @port.setter
+    def port(self, new_val):
+        # type: (Optional[int]) -> None
+        self._port = new_val
+    
+    @property
+    def ssl(self):
+        # type: () -> bool
+        return self._property_impl('ssl')
+    
+    @ssl.setter
+    def ssl(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._ssl = new_val
+    
+    @property
+    def urlPrefix(self):
+        # type: () -> str
+        return self._property_impl('urlPrefix')
+    
+    @urlPrefix.setter
+    def urlPrefix(self, new_val):
+        # type: (Optional[str]) -> None
+        self._urlPrefix = new_val
+
+
+class DisruptionManagement(CrdObject):
+    _properties = [
+        ('machineDisruptionBudgetNamespace', 'machineDisruptionBudgetNamespace', str, False, False),
+        ('manageMachineDisruptionBudgets', 'manageMachineDisruptionBudgets', bool, False, False),
+        ('managePodBudgets', 'managePodBudgets', bool, False, False),
+        ('osdMaintenanceTimeout', 'osdMaintenanceTimeout', int, False, False),
+        ('pgHealthCheckTimeout', 'pgHealthCheckTimeout', int, False, False)
+    ]        
+
+    def __init__(self,
+                 machineDisruptionBudgetNamespace=_omit,  # type: Optional[str]
+                 manageMachineDisruptionBudgets=_omit,  # type: Optional[bool]
+                 managePodBudgets=_omit,  # type: Optional[bool]
+                 osdMaintenanceTimeout=_omit,  # type: Optional[int]
+                 pgHealthCheckTimeout=_omit,  # type: Optional[int]
+                 ):
+        super(DisruptionManagement, self).__init__(
+            machineDisruptionBudgetNamespace=machineDisruptionBudgetNamespace,
+            manageMachineDisruptionBudgets=manageMachineDisruptionBudgets,
+            managePodBudgets=managePodBudgets,
+            osdMaintenanceTimeout=osdMaintenanceTimeout,
+            pgHealthCheckTimeout=pgHealthCheckTimeout,
+        )
+
+    @property
+    def machineDisruptionBudgetNamespace(self):
+        # type: () -> str
+        return self._property_impl('machineDisruptionBudgetNamespace')
+    
+    @machineDisruptionBudgetNamespace.setter
+    def machineDisruptionBudgetNamespace(self, new_val):
+        # type: (Optional[str]) -> None
+        self._machineDisruptionBudgetNamespace = new_val
+    
+    @property
+    def manageMachineDisruptionBudgets(self):
+        # type: () -> bool
+        return self._property_impl('manageMachineDisruptionBudgets')
+    
+    @manageMachineDisruptionBudgets.setter
+    def manageMachineDisruptionBudgets(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._manageMachineDisruptionBudgets = new_val
+    
+    @property
+    def managePodBudgets(self):
+        # type: () -> bool
+        return self._property_impl('managePodBudgets')
+    
+    @managePodBudgets.setter
+    def managePodBudgets(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._managePodBudgets = new_val
+    
+    @property
+    def osdMaintenanceTimeout(self):
+        # type: () -> int
+        return self._property_impl('osdMaintenanceTimeout')
+    
+    @osdMaintenanceTimeout.setter
+    def osdMaintenanceTimeout(self, new_val):
+        # type: (Optional[int]) -> None
+        self._osdMaintenanceTimeout = new_val
+    
+    @property
+    def pgHealthCheckTimeout(self):
+        # type: () -> int
+        return self._property_impl('pgHealthCheckTimeout')
+    
+    @pgHealthCheckTimeout.setter
+    def pgHealthCheckTimeout(self, new_val):
+        # type: (Optional[int]) -> None
+        self._pgHealthCheckTimeout = new_val
+
+
+class External(CrdObject):
+    _properties = [
+        ('enable', 'enable', bool, False, False)
+    ]        
+
+    def __init__(self,
+                 enable=_omit,  # type: Optional[bool]
+                 ):
+        super(External, self).__init__(
+            enable=enable,
+        )
+
+    @property
+    def enable(self):
+        # type: () -> bool
+        return self._property_impl('enable')
+    
+    @enable.setter
+    def enable(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._enable = new_val
+
+
+class Mon(CrdObject):
+    _properties = [
+        ('allowMultiplePerNode', 'allowMultiplePerNode', bool, False, False),
+        ('count', 'count', int, False, False),
+        ('stretchCluster', 'stretchCluster', 'StretchCluster', False, False),
+        ('volumeClaimTemplate', 'volumeClaimTemplate', 'VolumeClaimTemplate', False, False),
+        ('disabled', 'disabled', bool, False, False),
+        ('interval', 'interval', str, False, False),
+        ('timeout', 'timeout', str, False, False)
+    ]        
+
+    def __init__(self,
+                 allowMultiplePerNode=_omit,  # type: Optional[bool]
+                 count=_omit,  # type: Optional[int]
+                 stretchCluster=_omit,  # type: Optional[StretchCluster]
+                 volumeClaimTemplate=_omit,  # type: Optional[VolumeClaimTemplate]
+                 disabled=_omit,  # type: Optional[bool]
+                 interval=_omit,  # type: Optional[str]
+                 timeout=_omit,  # type: Optional[str]
+                 ):
+        super(Mon, self).__init__(
+            allowMultiplePerNode=allowMultiplePerNode,
+            count=count,
+            stretchCluster=stretchCluster,
+            volumeClaimTemplate=volumeClaimTemplate,
+            disabled=disabled,
+            interval=interval,
+            timeout=timeout,
+        )
+
+    @property
+    def allowMultiplePerNode(self):
+        # type: () -> bool
+        return self._property_impl('allowMultiplePerNode')
+    
+    @allowMultiplePerNode.setter
+    def allowMultiplePerNode(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._allowMultiplePerNode = new_val
+    
+    @property
+    def count(self):
+        # type: () -> int
+        return self._property_impl('count')
+    
+    @count.setter
+    def count(self, new_val):
+        # type: (Optional[int]) -> None
+        self._count = new_val
+    
+    @property
+    def stretchCluster(self):
+        # type: () -> StretchCluster
+        return self._property_impl('stretchCluster')
+    
+    @stretchCluster.setter
+    def stretchCluster(self, new_val):
+        # type: (Optional[StretchCluster]) -> None
+        self._stretchCluster = new_val
+    
+    @property
+    def volumeClaimTemplate(self):
+        # type: () -> VolumeClaimTemplate
+        return self._property_impl('volumeClaimTemplate')
+    
+    @volumeClaimTemplate.setter
+    def volumeClaimTemplate(self, new_val):
+        # type: (Optional[VolumeClaimTemplate]) -> None
+        self._volumeClaimTemplate = new_val
+    
+    @property
+    def disabled(self):
+        # type: () -> bool
+        return self._property_impl('disabled')
+    
+    @disabled.setter
+    def disabled(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._disabled = new_val
+    
+    @property
+    def interval(self):
+        # type: () -> str
+        return self._property_impl('interval')
+    
+    @interval.setter
+    def interval(self, new_val):
+        # type: (Optional[str]) -> None
+        self._interval = new_val
+    
+    @property
+    def timeout(self):
+        # type: () -> str
+        return self._property_impl('timeout')
+    
+    @timeout.setter
+    def timeout(self, new_val):
+        # type: (Optional[str]) -> None
+        self._timeout = new_val
+
+
+class Osd(CrdObject):
+    _properties = [
+        ('disabled', 'disabled', bool, False, False),
+        ('interval', 'interval', str, False, False),
+        ('timeout', 'timeout', str, False, False)
+    ]        
+
+    def __init__(self,
+                 disabled=_omit,  # type: Optional[bool]
+                 interval=_omit,  # type: Optional[str]
+                 timeout=_omit,  # type: Optional[str]
+                 ):
+        super(Osd, self).__init__(
+            disabled=disabled,
+            interval=interval,
+            timeout=timeout,
+        )
+
+    @property
+    def disabled(self):
+        # type: () -> bool
+        return self._property_impl('disabled')
+    
+    @disabled.setter
+    def disabled(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._disabled = new_val
+    
+    @property
+    def interval(self):
+        # type: () -> str
+        return self._property_impl('interval')
+    
+    @interval.setter
+    def interval(self, new_val):
+        # type: (Optional[str]) -> None
+        self._interval = new_val
+    
+    @property
+    def timeout(self):
+        # type: () -> str
+        return self._property_impl('timeout')
+    
+    @timeout.setter
+    def timeout(self, new_val):
+        # type: (Optional[str]) -> None
+        self._timeout = new_val
+
+
+class Status(CrdObject):
+    _properties = [
+        ('ceph', 'ceph', 'Ceph', False, False),
+        ('conditions', 'conditions', 'ConditionsList', False, False),
+        ('message', 'message', str, False, False),
+        ('phase', 'phase', str, False, False),
+        ('state', 'state', str, False, False),
+        ('storage', 'storage', 'Storage', False, False),
+        ('version', 'version', 'Version', False, False),
+        ('accessModes', 'accessModes', 'AccessModesList', False, False),
+        ('capacity', 'capacity', object, False, False),
+        ('disabled', 'disabled', bool, False, False),
+        ('interval', 'interval', str, False, False),
+        ('timeout', 'timeout', str, False, False)
+    ]        
+
+    def __init__(self,
+                 ceph=_omit,  # type: Optional[Ceph]
+                 conditions=_omit,  # type: Optional[Union[List[ConditionsItem], CrdObjectList]]
+                 message=_omit,  # type: Optional[str]
+                 phase=_omit,  # type: Optional[str]
+                 state=_omit,  # type: Optional[str]
+                 storage=_omit,  # type: Optional[Storage]
+                 version=_omit,  # type: Optional[Version]
+                 accessModes=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 capacity=_omit,  # type: Optional[Any]
+                 disabled=_omit,  # type: Optional[bool]
+                 interval=_omit,  # type: Optional[str]
+                 timeout=_omit,  # type: Optional[str]
+                 ):
+        super(Status, self).__init__(
+            ceph=ceph,
+            conditions=conditions,
+            message=message,
+            phase=phase,
+            state=state,
+            storage=storage,
+            version=version,
+            accessModes=accessModes,
+            capacity=capacity,
+            disabled=disabled,
+            interval=interval,
+            timeout=timeout,
+        )
+
+    @property
+    def ceph(self):
+        # type: () -> Ceph
+        return self._property_impl('ceph')
+    
+    @ceph.setter
+    def ceph(self, new_val):
+        # type: (Optional[Ceph]) -> None
+        self._ceph = new_val
+    
+    @property
+    def conditions(self):
+        # type: () -> Union[List[ConditionsItem], CrdObjectList]
+        return self._property_impl('conditions')
+    
+    @conditions.setter
+    def conditions(self, new_val):
+        # type: (Optional[Union[List[ConditionsItem], CrdObjectList]]) -> None
+        self._conditions = new_val
+    
+    @property
+    def message(self):
+        # type: () -> str
+        return self._property_impl('message')
+    
+    @message.setter
+    def message(self, new_val):
+        # type: (Optional[str]) -> None
+        self._message = new_val
+    
+    @property
+    def phase(self):
+        # type: () -> str
+        return self._property_impl('phase')
+    
+    @phase.setter
+    def phase(self, new_val):
+        # type: (Optional[str]) -> None
+        self._phase = new_val
+    
+    @property
+    def state(self):
+        # type: () -> str
+        return self._property_impl('state')
+    
+    @state.setter
+    def state(self, new_val):
+        # type: (Optional[str]) -> None
+        self._state = new_val
+    
+    @property
+    def storage(self):
+        # type: () -> Storage
+        return self._property_impl('storage')
+    
+    @storage.setter
+    def storage(self, new_val):
+        # type: (Optional[Storage]) -> None
+        self._storage = new_val
+    
+    @property
+    def version(self):
+        # type: () -> Version
+        return self._property_impl('version')
+    
+    @version.setter
+    def version(self, new_val):
+        # type: (Optional[Version]) -> None
+        self._version = new_val
+    
+    @property
+    def accessModes(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('accessModes')
+    
+    @accessModes.setter
+    def accessModes(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._accessModes = new_val
+    
+    @property
+    def capacity(self):
+        # type: () -> Any
+        return self._property_impl('capacity')
+    
+    @capacity.setter
+    def capacity(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._capacity = new_val
+    
+    @property
+    def disabled(self):
+        # type: () -> bool
+        return self._property_impl('disabled')
+    
+    @disabled.setter
+    def disabled(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._disabled = new_val
+    
+    @property
+    def interval(self):
+        # type: () -> str
+        return self._property_impl('interval')
+    
+    @interval.setter
+    def interval(self, new_val):
+        # type: (Optional[str]) -> None
+        self._interval = new_val
+    
+    @property
+    def timeout(self):
+        # type: () -> str
+        return self._property_impl('timeout')
+    
+    @timeout.setter
+    def timeout(self, new_val):
+        # type: (Optional[str]) -> None
+        self._timeout = new_val
+
+
+class DaemonHealth(CrdObject):
+    _properties = [
+        ('mon', 'mon', 'Mon', False, True),
+        ('osd', 'osd', 'Osd', False, True),
+        ('status', 'status', 'Status', False, True)
+    ]        
+
+    def __init__(self,
+                 mon=_omit,  # type: Optional[Mon]
+                 osd=_omit,  # type: Optional[Osd]
+                 status=_omit,  # type: Optional[Status]
+                 ):
+        super(DaemonHealth, self).__init__(
+            mon=mon,
+            osd=osd,
+            status=status,
+        )
+
+    @property
+    def mon(self):
+        # type: () -> Optional[Mon]
+        return self._property_impl('mon')
+    
+    @mon.setter
+    def mon(self, new_val):
+        # type: (Optional[Mon]) -> None
+        self._mon = new_val
+    
+    @property
+    def osd(self):
+        # type: () -> Optional[Osd]
+        return self._property_impl('osd')
+    
+    @osd.setter
+    def osd(self, new_val):
+        # type: (Optional[Osd]) -> None
+        self._osd = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Optional[Status]
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Status]) -> None
+        self._status = new_val
+
+
+class HealthCheck(CrdObject):
+    _properties = [
+        ('daemonHealth', 'daemonHealth', 'DaemonHealth', False, True),
+        ('livenessProbe', 'livenessProbe', object, False, False)
+    ]        
+
+    def __init__(self,
+                 daemonHealth=_omit,  # type: Optional[DaemonHealth]
+                 livenessProbe=_omit,  # type: Optional[Any]
+                 ):
+        super(HealthCheck, self).__init__(
+            daemonHealth=daemonHealth,
+            livenessProbe=livenessProbe,
+        )
+
+    @property
+    def daemonHealth(self):
+        # type: () -> Optional[DaemonHealth]
+        return self._property_impl('daemonHealth')
+    
+    @daemonHealth.setter
+    def daemonHealth(self, new_val):
+        # type: (Optional[DaemonHealth]) -> None
+        self._daemonHealth = new_val
+    
+    @property
+    def livenessProbe(self):
+        # type: () -> Any
+        return self._property_impl('livenessProbe')
+    
+    @livenessProbe.setter
+    def livenessProbe(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._livenessProbe = new_val
+
+
+class LogCollector(CrdObject):
+    _properties = [
+        ('enabled', 'enabled', bool, False, False),
+        ('periodicity', 'periodicity', str, False, False)
+    ]        
+
+    def __init__(self,
+                 enabled=_omit,  # type: Optional[bool]
+                 periodicity=_omit,  # type: Optional[str]
+                 ):
+        super(LogCollector, self).__init__(
+            enabled=enabled,
+            periodicity=periodicity,
+        )
+
+    @property
+    def enabled(self):
+        # type: () -> bool
+        return self._property_impl('enabled')
+    
+    @enabled.setter
+    def enabled(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._enabled = new_val
+    
+    @property
+    def periodicity(self):
+        # type: () -> str
+        return self._property_impl('periodicity')
+    
+    @periodicity.setter
+    def periodicity(self, new_val):
+        # type: (Optional[str]) -> None
+        self._periodicity = new_val
+
+
+class ModulesItem(CrdObject):
+    _properties = [
+        ('enabled', 'enabled', bool, False, False),
+        ('name', 'name', str, False, False)
+    ]        
+
+    def __init__(self,
+                 enabled=_omit,  # type: Optional[bool]
+                 name=_omit,  # type: Optional[str]
+                 ):
+        super(ModulesItem, self).__init__(
+            enabled=enabled,
+            name=name,
+        )
+
+    @property
+    def enabled(self):
+        # type: () -> bool
+        return self._property_impl('enabled')
+    
+    @enabled.setter
+    def enabled(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._enabled = new_val
+    
+    @property
+    def name(self):
+        # type: () -> str
+        return self._property_impl('name')
+    
+    @name.setter
+    def name(self, new_val):
+        # type: (Optional[str]) -> None
+        self._name = new_val
+
+
+class ModulesList(CrdObjectList):
+    _items_type = ModulesItem
+
+
+class Mgr(CrdObject):
+    _properties = [
+        ('allowMultiplePerNode', 'allowMultiplePerNode', bool, False, False),
+        ('count', 'count', int, False, False),
+        ('modules', 'modules', 'ModulesList', False, True)
+    ]        
+
+    def __init__(self,
+                 allowMultiplePerNode=_omit,  # type: Optional[bool]
+                 count=_omit,  # type: Optional[int]
+                 modules=_omit,  # type: Optional[Union[List[ModulesItem], CrdObjectList]]
+                 ):
+        super(Mgr, self).__init__(
+            allowMultiplePerNode=allowMultiplePerNode,
+            count=count,
+            modules=modules,
+        )
+
+    @property
+    def allowMultiplePerNode(self):
+        # type: () -> bool
+        return self._property_impl('allowMultiplePerNode')
+    
+    @allowMultiplePerNode.setter
+    def allowMultiplePerNode(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._allowMultiplePerNode = new_val
+    
+    @property
+    def count(self):
+        # type: () -> int
+        return self._property_impl('count')
+    
+    @count.setter
+    def count(self, new_val):
+        # type: (Optional[int]) -> None
+        self._count = new_val
+    
+    @property
+    def modules(self):
+        # type: () -> Optional[Union[List[ModulesItem], CrdObjectList]]
+        return self._property_impl('modules')
+    
+    @modules.setter
+    def modules(self, new_val):
+        # type: (Optional[Union[List[ModulesItem], CrdObjectList]]) -> None
+        self._modules = new_val
+
+
+class FinalizersList(CrdObjectList):
+    _items_type = str
+
+
+class Metadata(CrdObject):
+    _properties = [
+        ('annotations', 'annotations', object, False, False),
+        ('finalizers', 'finalizers', 'FinalizersList', False, False),
+        ('labels', 'labels', object, False, False),
+        ('name', 'name', str, False, False),
+        ('namespace', 'namespace', str, False, False)
+    ]        
+
+    def __init__(self,
+                 annotations=_omit,  # type: Optional[Any]
+                 finalizers=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 labels=_omit,  # type: Optional[Any]
+                 name=_omit,  # type: Optional[str]
+                 namespace=_omit,  # type: Optional[str]
+                 ):
+        super(Metadata, self).__init__(
+            annotations=annotations,
+            finalizers=finalizers,
+            labels=labels,
+            name=name,
+            namespace=namespace,
+        )
+
+    @property
+    def annotations(self):
+        # type: () -> Any
+        return self._property_impl('annotations')
+    
+    @annotations.setter
+    def annotations(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._annotations = new_val
+    
+    @property
+    def finalizers(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('finalizers')
+    
+    @finalizers.setter
+    def finalizers(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._finalizers = new_val
+    
+    @property
+    def labels(self):
+        # type: () -> Any
+        return self._property_impl('labels')
+    
+    @labels.setter
+    def labels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._labels = new_val
+    
+    @property
+    def name(self):
+        # type: () -> str
+        return self._property_impl('name')
+    
+    @name.setter
+    def name(self, new_val):
+        # type: (Optional[str]) -> None
+        self._name = new_val
+    
+    @property
+    def namespace(self):
+        # type: () -> str
+        return self._property_impl('namespace')
+    
+    @namespace.setter
+    def namespace(self, new_val):
+        # type: (Optional[str]) -> None
+        self._namespace = new_val
+
+
+class AccessModesList(CrdObjectList):
+    _items_type = str
+
+
+class DataSource(CrdObject):
+    _properties = [
+        ('apiGroup', 'apiGroup', str, False, False),
+        ('kind', 'kind', str, True, False),
+        ('name', 'name', str, True, False)
+    ]        
+
+    def __init__(self,
+                 kind,  # type: str
+                 name,  # type: str
+                 apiGroup=_omit,  # type: Optional[str]
+                 ):
+        super(DataSource, self).__init__(
+            kind=kind,
+            name=name,
+            apiGroup=apiGroup,
+        )
+
+    @property
+    def apiGroup(self):
+        # type: () -> str
+        return self._property_impl('apiGroup')
+    
+    @apiGroup.setter
+    def apiGroup(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiGroup = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (str) -> None
+        self._kind = new_val
+    
+    @property
+    def name(self):
+        # type: () -> str
+        return self._property_impl('name')
+    
+    @name.setter
+    def name(self, new_val):
+        # type: (str) -> None
+        self._name = new_val
+
+
+class Resources(CrdObject):
+    _properties = [
+        ('limits', 'limits', object, False, False),
+        ('requests', 'requests', object, False, False)
+    ]        
+
+    def __init__(self,
+                 limits=_omit,  # type: Optional[Any]
+                 requests=_omit,  # type: Optional[Any]
+                 ):
+        super(Resources, self).__init__(
+            limits=limits,
+            requests=requests,
+        )
+
+    @property
+    def limits(self):
+        # type: () -> Any
+        return self._property_impl('limits')
+    
+    @limits.setter
+    def limits(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._limits = new_val
+    
+    @property
+    def requests(self):
+        # type: () -> Any
+        return self._property_impl('requests')
+    
+    @requests.setter
+    def requests(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._requests = new_val
+
+
+class ValuesList(CrdObjectList):
+    _items_type = str
+
+
+class MatchExpressionsItem(CrdObject):
+    _properties = [
+        ('key', 'key', str, True, False),
+        ('operator', 'operator', str, True, False),
+        ('values', 'values', 'ValuesList', False, False)
+    ]        
+
+    def __init__(self,
+                 key,  # type: str
+                 operator,  # type: str
+                 values=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(MatchExpressionsItem, self).__init__(
+            key=key,
+            operator=operator,
+            values=values,
+        )
+
+    @property
+    def key(self):
+        # type: () -> str
+        return self._property_impl('key')
+    
+    @key.setter
+    def key(self, new_val):
+        # type: (str) -> None
+        self._key = new_val
+    
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._property_impl('operator')
+    
+    @operator.setter
+    def operator(self, new_val):
+        # type: (str) -> None
+        self._operator = new_val
+    
+    @property
+    def values(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('values')
+    
+    @values.setter
+    def values(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._values = new_val
+
+
+class MatchExpressionsList(CrdObjectList):
+    _items_type = MatchExpressionsItem
+
+
+class Selector(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchLabels', 'matchLabels', object, False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchLabels=_omit,  # type: Optional[Any]
+                 ):
+        super(Selector, self).__init__(
+            matchExpressions=matchExpressions,
+            matchLabels=matchLabels,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchLabels(self):
+        # type: () -> Any
+        return self._property_impl('matchLabels')
+    
+    @matchLabels.setter
+    def matchLabels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._matchLabels = new_val
+
+
+class Spec(CrdObject):
+    _properties = [
+        ('annotations', 'annotations', object, False, True),
+        ('cephVersion', 'cephVersion', 'CephVersion', False, True),
+        ('cleanupPolicy', 'cleanupPolicy', 'CleanupPolicy', False, True),
+        ('continueUpgradeAfterChecksEvenIfNotHealthy', 'continueUpgradeAfterChecksEvenIfNotHealthy', bool, False, False),
+        ('crashCollector', 'crashCollector', 'CrashCollector', False, True),
+        ('dashboard', 'dashboard', 'Dashboard', False, True),
+        ('dataDirHostPath', 'dataDirHostPath', str, False, False),
+        ('disruptionManagement', 'disruptionManagement', 'DisruptionManagement', False, True),
+        ('external', 'external', 'External', False, True),
+        ('healthCheck', 'healthCheck', 'HealthCheck', False, True),
+        ('labels', 'labels', object, False, True),
+        ('logCollector', 'logCollector', 'LogCollector', False, True),
+        ('mgr', 'mgr', 'Mgr', False, True),
+        ('mon', 'mon', 'Mon', False, True),
+        ('monitoring', 'monitoring', 'Monitoring', False, True),
+        ('network', 'network', 'Network', False, True),
+        ('placement', 'placement', object, False, True),
+        ('priorityClassNames', 'priorityClassNames', object, False, True),
+        ('removeOSDsIfOutAndSafeToRemove', 'removeOSDsIfOutAndSafeToRemove', bool, False, False),
+        ('resources', 'resources', object, False, True),
+        ('security', 'security', 'Security', False, True),
+        ('skipUpgradeChecks', 'skipUpgradeChecks', bool, False, False),
+        ('storage', 'storage', 'Storage', False, True),
+        ('waitTimeoutForHealthyOSDInMinutes', 'waitTimeoutForHealthyOSDInMinutes', int, False, False),
+        ('accessModes', 'accessModes', 'AccessModesList', False, False),
+        ('dataSource', 'dataSource', 'DataSource', False, False),
+        ('selector', 'selector', 'Selector', False, False),
+        ('storageClassName', 'storageClassName', str, False, False),
+        ('volumeMode', 'volumeMode', str, False, False),
+        ('volumeName', 'volumeName', str, False, False)
+    ]        
+
+    def __init__(self,
+                 annotations=_omit,  # type: Optional[Any]
+                 cephVersion=_omit,  # type: Optional[CephVersion]
+                 cleanupPolicy=_omit,  # type: Optional[CleanupPolicy]
+                 continueUpgradeAfterChecksEvenIfNotHealthy=_omit,  # type: Optional[bool]
+                 crashCollector=_omit,  # type: Optional[CrashCollector]
+                 dashboard=_omit,  # type: Optional[Dashboard]
+                 dataDirHostPath=_omit,  # type: Optional[str]
+                 disruptionManagement=_omit,  # type: Optional[DisruptionManagement]
+                 external=_omit,  # type: Optional[External]
+                 healthCheck=_omit,  # type: Optional[HealthCheck]
+                 labels=_omit,  # type: Optional[Any]
+                 logCollector=_omit,  # type: Optional[LogCollector]
+                 mgr=_omit,  # type: Optional[Mgr]
+                 mon=_omit,  # type: Optional[Mon]
+                 monitoring=_omit,  # type: Optional[Monitoring]
+                 network=_omit,  # type: Optional[Network]
+                 placement=_omit,  # type: Optional[Any]
+                 priorityClassNames=_omit,  # type: Optional[Any]
+                 removeOSDsIfOutAndSafeToRemove=_omit,  # type: Optional[bool]
+                 resources=_omit,  # type: Optional[Any]
+                 security=_omit,  # type: Optional[Security]
+                 skipUpgradeChecks=_omit,  # type: Optional[bool]
+                 storage=_omit,  # type: Optional[Storage]
+                 waitTimeoutForHealthyOSDInMinutes=_omit,  # type: Optional[int]
+                 accessModes=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 dataSource=_omit,  # type: Optional[DataSource]
+                 selector=_omit,  # type: Optional[Selector]
+                 storageClassName=_omit,  # type: Optional[str]
+                 volumeMode=_omit,  # type: Optional[str]
+                 volumeName=_omit,  # type: Optional[str]
+                 ):
+        super(Spec, self).__init__(
+            annotations=annotations,
+            cephVersion=cephVersion,
+            cleanupPolicy=cleanupPolicy,
+            continueUpgradeAfterChecksEvenIfNotHealthy=continueUpgradeAfterChecksEvenIfNotHealthy,
+            crashCollector=crashCollector,
+            dashboard=dashboard,
+            dataDirHostPath=dataDirHostPath,
+            disruptionManagement=disruptionManagement,
+            external=external,
+            healthCheck=healthCheck,
+            labels=labels,
+            logCollector=logCollector,
+            mgr=mgr,
+            mon=mon,
+            monitoring=monitoring,
+            network=network,
+            placement=placement,
+            priorityClassNames=priorityClassNames,
+            removeOSDsIfOutAndSafeToRemove=removeOSDsIfOutAndSafeToRemove,
+            resources=resources,
+            security=security,
+            skipUpgradeChecks=skipUpgradeChecks,
+            storage=storage,
+            waitTimeoutForHealthyOSDInMinutes=waitTimeoutForHealthyOSDInMinutes,
+            accessModes=accessModes,
+            dataSource=dataSource,
+            selector=selector,
+            storageClassName=storageClassName,
+            volumeMode=volumeMode,
+            volumeName=volumeName,
+        )
+
+    @property
+    def annotations(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('annotations')
+    
+    @annotations.setter
+    def annotations(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._annotations = new_val
+    
+    @property
+    def cephVersion(self):
+        # type: () -> Optional[CephVersion]
+        return self._property_impl('cephVersion')
+    
+    @cephVersion.setter
+    def cephVersion(self, new_val):
+        # type: (Optional[CephVersion]) -> None
+        self._cephVersion = new_val
+    
+    @property
+    def cleanupPolicy(self):
+        # type: () -> Optional[CleanupPolicy]
+        return self._property_impl('cleanupPolicy')
+    
+    @cleanupPolicy.setter
+    def cleanupPolicy(self, new_val):
+        # type: (Optional[CleanupPolicy]) -> None
+        self._cleanupPolicy = new_val
+    
+    @property
+    def continueUpgradeAfterChecksEvenIfNotHealthy(self):
+        # type: () -> bool
+        return self._property_impl('continueUpgradeAfterChecksEvenIfNotHealthy')
+    
+    @continueUpgradeAfterChecksEvenIfNotHealthy.setter
+    def continueUpgradeAfterChecksEvenIfNotHealthy(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._continueUpgradeAfterChecksEvenIfNotHealthy = new_val
+    
+    @property
+    def crashCollector(self):
+        # type: () -> Optional[CrashCollector]
+        return self._property_impl('crashCollector')
+    
+    @crashCollector.setter
+    def crashCollector(self, new_val):
+        # type: (Optional[CrashCollector]) -> None
+        self._crashCollector = new_val
+    
+    @property
+    def dashboard(self):
+        # type: () -> Optional[Dashboard]
+        return self._property_impl('dashboard')
+    
+    @dashboard.setter
+    def dashboard(self, new_val):
+        # type: (Optional[Dashboard]) -> None
+        self._dashboard = new_val
+    
+    @property
+    def dataDirHostPath(self):
+        # type: () -> str
+        return self._property_impl('dataDirHostPath')
+    
+    @dataDirHostPath.setter
+    def dataDirHostPath(self, new_val):
+        # type: (Optional[str]) -> None
+        self._dataDirHostPath = new_val
+    
+    @property
+    def disruptionManagement(self):
+        # type: () -> Optional[DisruptionManagement]
+        return self._property_impl('disruptionManagement')
+    
+    @disruptionManagement.setter
+    def disruptionManagement(self, new_val):
+        # type: (Optional[DisruptionManagement]) -> None
+        self._disruptionManagement = new_val
+    
+    @property
+    def external(self):
+        # type: () -> Optional[External]
+        return self._property_impl('external')
+    
+    @external.setter
+    def external(self, new_val):
+        # type: (Optional[External]) -> None
+        self._external = new_val
+    
+    @property
+    def healthCheck(self):
+        # type: () -> Optional[HealthCheck]
+        return self._property_impl('healthCheck')
+    
+    @healthCheck.setter
+    def healthCheck(self, new_val):
+        # type: (Optional[HealthCheck]) -> None
+        self._healthCheck = new_val
+    
+    @property
+    def labels(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('labels')
+    
+    @labels.setter
+    def labels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._labels = new_val
+    
+    @property
+    def logCollector(self):
+        # type: () -> Optional[LogCollector]
+        return self._property_impl('logCollector')
+    
+    @logCollector.setter
+    def logCollector(self, new_val):
+        # type: (Optional[LogCollector]) -> None
+        self._logCollector = new_val
+    
+    @property
+    def mgr(self):
+        # type: () -> Optional[Mgr]
+        return self._property_impl('mgr')
+    
+    @mgr.setter
+    def mgr(self, new_val):
+        # type: (Optional[Mgr]) -> None
+        self._mgr = new_val
+    
+    @property
+    def mon(self):
+        # type: () -> Optional[Mon]
+        return self._property_impl('mon')
+    
+    @mon.setter
+    def mon(self, new_val):
+        # type: (Optional[Mon]) -> None
+        self._mon = new_val
+    
+    @property
+    def monitoring(self):
+        # type: () -> Optional[Monitoring]
+        return self._property_impl('monitoring')
+    
+    @monitoring.setter
+    def monitoring(self, new_val):
+        # type: (Optional[Monitoring]) -> None
+        self._monitoring = new_val
+    
+    @property
+    def network(self):
+        # type: () -> Optional[Network]
+        return self._property_impl('network')
+    
+    @network.setter
+    def network(self, new_val):
+        # type: (Optional[Network]) -> None
+        self._network = new_val
+    
+    @property
+    def placement(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('placement')
+    
+    @placement.setter
+    def placement(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._placement = new_val
+    
+    @property
+    def priorityClassNames(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('priorityClassNames')
+    
+    @priorityClassNames.setter
+    def priorityClassNames(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._priorityClassNames = new_val
+    
+    @property
+    def removeOSDsIfOutAndSafeToRemove(self):
+        # type: () -> bool
+        return self._property_impl('removeOSDsIfOutAndSafeToRemove')
+    
+    @removeOSDsIfOutAndSafeToRemove.setter
+    def removeOSDsIfOutAndSafeToRemove(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._removeOSDsIfOutAndSafeToRemove = new_val
+    
+    @property
+    def resources(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('resources')
+    
+    @resources.setter
+    def resources(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._resources = new_val
+    
+    @property
+    def security(self):
+        # type: () -> Optional[Security]
+        return self._property_impl('security')
+    
+    @security.setter
+    def security(self, new_val):
+        # type: (Optional[Security]) -> None
+        self._security = new_val
+    
+    @property
+    def skipUpgradeChecks(self):
+        # type: () -> bool
+        return self._property_impl('skipUpgradeChecks')
+    
+    @skipUpgradeChecks.setter
+    def skipUpgradeChecks(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._skipUpgradeChecks = new_val
+    
+    @property
+    def storage(self):
+        # type: () -> Optional[Storage]
+        return self._property_impl('storage')
+    
+    @storage.setter
+    def storage(self, new_val):
+        # type: (Optional[Storage]) -> None
+        self._storage = new_val
+    
+    @property
+    def waitTimeoutForHealthyOSDInMinutes(self):
+        # type: () -> int
+        return self._property_impl('waitTimeoutForHealthyOSDInMinutes')
+    
+    @waitTimeoutForHealthyOSDInMinutes.setter
+    def waitTimeoutForHealthyOSDInMinutes(self, new_val):
+        # type: (Optional[int]) -> None
+        self._waitTimeoutForHealthyOSDInMinutes = new_val
+    
+    @property
+    def accessModes(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('accessModes')
+    
+    @accessModes.setter
+    def accessModes(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._accessModes = new_val
+    
+    @property
+    def dataSource(self):
+        # type: () -> DataSource
+        return self._property_impl('dataSource')
+    
+    @dataSource.setter
+    def dataSource(self, new_val):
+        # type: (Optional[DataSource]) -> None
+        self._dataSource = new_val
+    
+    @property
+    def selector(self):
+        # type: () -> Selector
+        return self._property_impl('selector')
+    
+    @selector.setter
+    def selector(self, new_val):
+        # type: (Optional[Selector]) -> None
+        self._selector = new_val
+    
+    @property
+    def storageClassName(self):
+        # type: () -> str
+        return self._property_impl('storageClassName')
+    
+    @storageClassName.setter
+    def storageClassName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._storageClassName = new_val
+    
+    @property
+    def volumeMode(self):
+        # type: () -> str
+        return self._property_impl('volumeMode')
+    
+    @volumeMode.setter
+    def volumeMode(self, new_val):
+        # type: (Optional[str]) -> None
+        self._volumeMode = new_val
+    
+    @property
+    def volumeName(self):
+        # type: () -> str
+        return self._property_impl('volumeName')
+    
+    @volumeName.setter
+    def volumeName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._volumeName = new_val
+
+
+class ConditionsItem(CrdObject):
+    _properties = [
+        ('lastHeartbeatTime', 'lastHeartbeatTime', str, False, False),
+        ('lastTransitionTime', 'lastTransitionTime', str, False, False),
+        ('message', 'message', str, False, False),
+        ('reason', 'reason', str, False, False),
+        ('status', 'status', str, False, False),
+        ('type', 'type', str, False, False),
+        ('lastProbeTime', 'lastProbeTime', str, False, False)
+    ]        
+
+    def __init__(self,
+                 lastHeartbeatTime=_omit,  # type: Optional[str]
+                 lastTransitionTime=_omit,  # type: Optional[str]
+                 message=_omit,  # type: Optional[str]
+                 reason=_omit,  # type: Optional[str]
+                 status=_omit,  # type: Optional[str]
+                 type=_omit,  # type: Optional[str]
+                 lastProbeTime=_omit,  # type: Optional[str]
+                 ):
+        super(ConditionsItem, self).__init__(
+            lastHeartbeatTime=lastHeartbeatTime,
+            lastTransitionTime=lastTransitionTime,
+            message=message,
+            reason=reason,
+            status=status,
+            type=type,
+            lastProbeTime=lastProbeTime,
+        )
+
+    @property
+    def lastHeartbeatTime(self):
+        # type: () -> str
+        return self._property_impl('lastHeartbeatTime')
+    
+    @lastHeartbeatTime.setter
+    def lastHeartbeatTime(self, new_val):
+        # type: (Optional[str]) -> None
+        self._lastHeartbeatTime = new_val
+    
+    @property
+    def lastTransitionTime(self):
+        # type: () -> str
+        return self._property_impl('lastTransitionTime')
+    
+    @lastTransitionTime.setter
+    def lastTransitionTime(self, new_val):
+        # type: (Optional[str]) -> None
+        self._lastTransitionTime = new_val
+    
+    @property
+    def message(self):
+        # type: () -> str
+        return self._property_impl('message')
+    
+    @message.setter
+    def message(self, new_val):
+        # type: (Optional[str]) -> None
+        self._message = new_val
+    
+    @property
+    def reason(self):
+        # type: () -> str
+        return self._property_impl('reason')
+    
+    @reason.setter
+    def reason(self, new_val):
+        # type: (Optional[str]) -> None
+        self._reason = new_val
+    
+    @property
+    def status(self):
+        # type: () -> str
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[str]) -> None
+        self._status = new_val
+    
+    @property
+    def type(self):
+        # type: () -> str
+        return self._property_impl('type')
+    
+    @type.setter
+    def type(self, new_val):
+        # type: (Optional[str]) -> None
+        self._type = new_val
+    
+    @property
+    def lastProbeTime(self):
+        # type: () -> str
+        return self._property_impl('lastProbeTime')
+    
+    @lastProbeTime.setter
+    def lastProbeTime(self, new_val):
+        # type: (Optional[str]) -> None
+        self._lastProbeTime = new_val
+
+
+class ConditionsList(CrdObjectList):
+    _items_type = ConditionsItem
+
+
+class VolumeClaimTemplate(CrdObject):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('kind', 'kind', str, False, False),
+        ('metadata', 'metadata', 'Metadata', False, False),
+        ('spec', 'spec', 'Spec', False, False),
+        ('status', 'status', 'Status', False, False)
+    ]        
+
+    def __init__(self,
+                 apiVersion=_omit,  # type: Optional[str]
+                 kind=_omit,  # type: Optional[str]
+                 metadata=_omit,  # type: Optional[Metadata]
+                 spec=_omit,  # type: Optional[Spec]
+                 status=_omit,  # type: Optional[Status]
+                 ):
+        super(VolumeClaimTemplate, self).__init__(
+            apiVersion=apiVersion,
+            kind=kind,
+            metadata=metadata,
+            spec=spec,
+            status=status,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Metadata
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Optional[Metadata]) -> None
+        self._metadata = new_val
+    
+    @property
+    def spec(self):
+        # type: () -> Spec
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Optional[Spec]) -> None
+        self._spec = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Status
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Status]) -> None
+        self._status = new_val
+
+
+class ZonesItem(CrdObject):
+    _properties = [
+        ('arbiter', 'arbiter', bool, False, False),
+        ('name', 'name', str, False, False),
+        ('volumeClaimTemplate', 'volumeClaimTemplate', 'VolumeClaimTemplate', False, False)
+    ]        
+
+    def __init__(self,
+                 arbiter=_omit,  # type: Optional[bool]
+                 name=_omit,  # type: Optional[str]
+                 volumeClaimTemplate=_omit,  # type: Optional[VolumeClaimTemplate]
+                 ):
+        super(ZonesItem, self).__init__(
+            arbiter=arbiter,
+            name=name,
+            volumeClaimTemplate=volumeClaimTemplate,
+        )
+
+    @property
+    def arbiter(self):
+        # type: () -> bool
+        return self._property_impl('arbiter')
+    
+    @arbiter.setter
+    def arbiter(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._arbiter = new_val
+    
+    @property
+    def name(self):
+        # type: () -> str
+        return self._property_impl('name')
+    
+    @name.setter
+    def name(self, new_val):
+        # type: (Optional[str]) -> None
+        self._name = new_val
+    
+    @property
+    def volumeClaimTemplate(self):
+        # type: () -> VolumeClaimTemplate
+        return self._property_impl('volumeClaimTemplate')
+    
+    @volumeClaimTemplate.setter
+    def volumeClaimTemplate(self, new_val):
+        # type: (Optional[VolumeClaimTemplate]) -> None
+        self._volumeClaimTemplate = new_val
+
+
+class ZonesList(CrdObjectList):
+    _items_type = ZonesItem
+
+
+class StretchCluster(CrdObject):
+    _properties = [
+        ('failureDomainLabel', 'failureDomainLabel', str, False, False),
+        ('subFailureDomain', 'subFailureDomain', str, False, False),
+        ('zones', 'zones', 'ZonesList', False, True)
+    ]        
+
+    def __init__(self,
+                 failureDomainLabel=_omit,  # type: Optional[str]
+                 subFailureDomain=_omit,  # type: Optional[str]
+                 zones=_omit,  # type: Optional[Union[List[ZonesItem], CrdObjectList]]
+                 ):
+        super(StretchCluster, self).__init__(
+            failureDomainLabel=failureDomainLabel,
+            subFailureDomain=subFailureDomain,
+            zones=zones,
+        )
+
+    @property
+    def failureDomainLabel(self):
+        # type: () -> str
+        return self._property_impl('failureDomainLabel')
+    
+    @failureDomainLabel.setter
+    def failureDomainLabel(self, new_val):
+        # type: (Optional[str]) -> None
+        self._failureDomainLabel = new_val
+    
+    @property
+    def subFailureDomain(self):
+        # type: () -> str
+        return self._property_impl('subFailureDomain')
+    
+    @subFailureDomain.setter
+    def subFailureDomain(self, new_val):
+        # type: (Optional[str]) -> None
+        self._subFailureDomain = new_val
+    
+    @property
+    def zones(self):
+        # type: () -> Optional[Union[List[ZonesItem], CrdObjectList]]
+        return self._property_impl('zones')
+    
+    @zones.setter
+    def zones(self, new_val):
+        # type: (Optional[Union[List[ZonesItem], CrdObjectList]]) -> None
+        self._zones = new_val
+
+
+class TargetRef(CrdObject):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('fieldPath', 'fieldPath', str, False, False),
+        ('kind', 'kind', str, False, False),
+        ('name', 'name', str, False, False),
+        ('namespace', 'namespace', str, False, False),
+        ('resourceVersion', 'resourceVersion', str, False, False),
+        ('uid', 'uid', str, False, False)
+    ]        
+
+    def __init__(self,
+                 apiVersion=_omit,  # type: Optional[str]
+                 fieldPath=_omit,  # type: Optional[str]
+                 kind=_omit,  # type: Optional[str]
+                 name=_omit,  # type: Optional[str]
+                 namespace=_omit,  # type: Optional[str]
+                 resourceVersion=_omit,  # type: Optional[str]
+                 uid=_omit,  # type: Optional[str]
+                 ):
+        super(TargetRef, self).__init__(
+            apiVersion=apiVersion,
+            fieldPath=fieldPath,
+            kind=kind,
+            name=name,
+            namespace=namespace,
+            resourceVersion=resourceVersion,
+            uid=uid,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def fieldPath(self):
+        # type: () -> str
+        return self._property_impl('fieldPath')
+    
+    @fieldPath.setter
+    def fieldPath(self, new_val):
+        # type: (Optional[str]) -> None
+        self._fieldPath = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def name(self):
+        # type: () -> str
+        return self._property_impl('name')
+    
+    @name.setter
+    def name(self, new_val):
+        # type: (Optional[str]) -> None
+        self._name = new_val
+    
+    @property
+    def namespace(self):
+        # type: () -> str
+        return self._property_impl('namespace')
+    
+    @namespace.setter
+    def namespace(self, new_val):
+        # type: (Optional[str]) -> None
+        self._namespace = new_val
+    
+    @property
+    def resourceVersion(self):
+        # type: () -> str
+        return self._property_impl('resourceVersion')
+    
+    @resourceVersion.setter
+    def resourceVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._resourceVersion = new_val
+    
+    @property
+    def uid(self):
+        # type: () -> str
+        return self._property_impl('uid')
+    
+    @uid.setter
+    def uid(self, new_val):
+        # type: (Optional[str]) -> None
+        self._uid = new_val
+
+
+class ExternalMgrEndpointsItem(CrdObject):
+    _properties = [
+        ('hostname', 'hostname', str, False, False),
+        ('ip', 'ip', str, True, False),
+        ('nodeName', 'nodeName', str, False, False),
+        ('targetRef', 'targetRef', 'TargetRef', False, False)
+    ]        
+
+    def __init__(self,
+                 ip,  # type: str
+                 hostname=_omit,  # type: Optional[str]
+                 nodeName=_omit,  # type: Optional[str]
+                 targetRef=_omit,  # type: Optional[TargetRef]
+                 ):
+        super(ExternalMgrEndpointsItem, self).__init__(
+            ip=ip,
+            hostname=hostname,
+            nodeName=nodeName,
+            targetRef=targetRef,
+        )
+
+    @property
+    def hostname(self):
+        # type: () -> str
+        return self._property_impl('hostname')
+    
+    @hostname.setter
+    def hostname(self, new_val):
+        # type: (Optional[str]) -> None
+        self._hostname = new_val
+    
+    @property
+    def ip(self):
+        # type: () -> str
+        return self._property_impl('ip')
+    
+    @ip.setter
+    def ip(self, new_val):
+        # type: (str) -> None
+        self._ip = new_val
+    
+    @property
+    def nodeName(self):
+        # type: () -> str
+        return self._property_impl('nodeName')
+    
+    @nodeName.setter
+    def nodeName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._nodeName = new_val
+    
+    @property
+    def targetRef(self):
+        # type: () -> TargetRef
+        return self._property_impl('targetRef')
+    
+    @targetRef.setter
+    def targetRef(self, new_val):
+        # type: (Optional[TargetRef]) -> None
+        self._targetRef = new_val
+
+
+class ExternalMgrEndpointsList(CrdObjectList):
+    _items_type = ExternalMgrEndpointsItem
+
+
+class Monitoring(CrdObject):
+    _properties = [
+        ('enabled', 'enabled', bool, False, False),
+        ('externalMgrEndpoints', 'externalMgrEndpoints', 'ExternalMgrEndpointsList', False, True),
+        ('externalMgrPrometheusPort', 'externalMgrPrometheusPort', int, False, False),
+        ('rulesNamespace', 'rulesNamespace', str, False, False)
+    ]        
+
+    def __init__(self,
+                 enabled=_omit,  # type: Optional[bool]
+                 externalMgrEndpoints=_omit,  # type: Optional[Union[List[ExternalMgrEndpointsItem], CrdObjectList]]
+                 externalMgrPrometheusPort=_omit,  # type: Optional[int]
+                 rulesNamespace=_omit,  # type: Optional[str]
+                 ):
+        super(Monitoring, self).__init__(
+            enabled=enabled,
+            externalMgrEndpoints=externalMgrEndpoints,
+            externalMgrPrometheusPort=externalMgrPrometheusPort,
+            rulesNamespace=rulesNamespace,
+        )
+
+    @property
+    def enabled(self):
+        # type: () -> bool
+        return self._property_impl('enabled')
+    
+    @enabled.setter
+    def enabled(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._enabled = new_val
+    
+    @property
+    def externalMgrEndpoints(self):
+        # type: () -> Optional[Union[List[ExternalMgrEndpointsItem], CrdObjectList]]
+        return self._property_impl('externalMgrEndpoints')
+    
+    @externalMgrEndpoints.setter
+    def externalMgrEndpoints(self, new_val):
+        # type: (Optional[Union[List[ExternalMgrEndpointsItem], CrdObjectList]]) -> None
+        self._externalMgrEndpoints = new_val
+    
+    @property
+    def externalMgrPrometheusPort(self):
+        # type: () -> int
+        return self._property_impl('externalMgrPrometheusPort')
+    
+    @externalMgrPrometheusPort.setter
+    def externalMgrPrometheusPort(self, new_val):
+        # type: (Optional[int]) -> None
+        self._externalMgrPrometheusPort = new_val
+    
+    @property
+    def rulesNamespace(self):
+        # type: () -> str
+        return self._property_impl('rulesNamespace')
+    
+    @rulesNamespace.setter
+    def rulesNamespace(self, new_val):
+        # type: (Optional[str]) -> None
+        self._rulesNamespace = new_val
+
+
+class Network(CrdObject):
+    _properties = [
+        ('dualStack', 'dualStack', bool, False, False),
+        ('hostNetwork', 'hostNetwork', bool, False, False),
+        ('ipFamily', 'ipFamily', str, False, True),
+        ('provider', 'provider', str, False, True),
+        ('selectors', 'selectors', object, False, True)
+    ]        
+
+    def __init__(self,
+                 dualStack=_omit,  # type: Optional[bool]
+                 hostNetwork=_omit,  # type: Optional[bool]
+                 ipFamily=_omit,  # type: Optional[str]
+                 provider=_omit,  # type: Optional[str]
+                 selectors=_omit,  # type: Optional[Any]
+                 ):
+        super(Network, self).__init__(
+            dualStack=dualStack,
+            hostNetwork=hostNetwork,
+            ipFamily=ipFamily,
+            provider=provider,
+            selectors=selectors,
+        )
+
+    @property
+    def dualStack(self):
+        # type: () -> bool
+        return self._property_impl('dualStack')
+    
+    @dualStack.setter
+    def dualStack(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._dualStack = new_val
+    
+    @property
+    def hostNetwork(self):
+        # type: () -> bool
+        return self._property_impl('hostNetwork')
+    
+    @hostNetwork.setter
+    def hostNetwork(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._hostNetwork = new_val
+    
+    @property
+    def ipFamily(self):
+        # type: () -> Optional[str]
+        return self._property_impl('ipFamily')
+    
+    @ipFamily.setter
+    def ipFamily(self, new_val):
+        # type: (Optional[str]) -> None
+        self._ipFamily = new_val
+    
+    @property
+    def provider(self):
+        # type: () -> Optional[str]
+        return self._property_impl('provider')
+    
+    @provider.setter
+    def provider(self, new_val):
+        # type: (Optional[str]) -> None
+        self._provider = new_val
+    
+    @property
+    def selectors(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('selectors')
+    
+    @selectors.setter
+    def selectors(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._selectors = new_val
+
+
+class Kms(CrdObject):
+    _properties = [
+        ('connectionDetails', 'connectionDetails', object, False, True),
+        ('tokenSecretName', 'tokenSecretName', str, False, False)
+    ]        
+
+    def __init__(self,
+                 connectionDetails=_omit,  # type: Optional[Any]
+                 tokenSecretName=_omit,  # type: Optional[str]
+                 ):
+        super(Kms, self).__init__(
+            connectionDetails=connectionDetails,
+            tokenSecretName=tokenSecretName,
+        )
+
+    @property
+    def connectionDetails(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('connectionDetails')
+    
+    @connectionDetails.setter
+    def connectionDetails(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._connectionDetails = new_val
+    
+    @property
+    def tokenSecretName(self):
+        # type: () -> str
+        return self._property_impl('tokenSecretName')
+    
+    @tokenSecretName.setter
+    def tokenSecretName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._tokenSecretName = new_val
+
+
+class Security(CrdObject):
+    _properties = [
+        ('kms', 'kms', 'Kms', False, True)
+    ]        
+
+    def __init__(self,
+                 kms=_omit,  # type: Optional[Kms]
+                 ):
+        super(Security, self).__init__(
+            kms=kms,
+        )
+
+    @property
+    def kms(self):
+        # type: () -> Optional[Kms]
+        return self._property_impl('kms')
+    
+    @kms.setter
+    def kms(self, new_val):
+        # type: (Optional[Kms]) -> None
+        self._kms = new_val
+
+
+class DevicesItem(CrdObject):
+    _properties = [
+        ('config', 'config', object, False, False),
+        ('fullpath', 'fullpath', str, False, False),
+        ('name', 'name', str, False, False)
+    ]        
+
+    def __init__(self,
+                 config=_omit,  # type: Optional[Any]
+                 fullpath=_omit,  # type: Optional[str]
+                 name=_omit,  # type: Optional[str]
+                 ):
+        super(DevicesItem, self).__init__(
+            config=config,
+            fullpath=fullpath,
+            name=name,
+        )
+
+    @property
+    def config(self):
+        # type: () -> Any
+        return self._property_impl('config')
+    
+    @config.setter
+    def config(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._config = new_val
+    
+    @property
+    def fullpath(self):
+        # type: () -> str
+        return self._property_impl('fullpath')
+    
+    @fullpath.setter
+    def fullpath(self, new_val):
+        # type: (Optional[str]) -> None
+        self._fullpath = new_val
+    
+    @property
+    def name(self):
+        # type: () -> str
+        return self._property_impl('name')
+    
+    @name.setter
+    def name(self, new_val):
+        # type: (Optional[str]) -> None
+        self._name = new_val
+
+
+class DevicesList(CrdObjectList):
+    _items_type = DevicesItem
+
+
+class VolumeClaimTemplatesItem(CrdObject):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('kind', 'kind', str, False, False),
+        ('metadata', 'metadata', 'Metadata', False, False),
+        ('spec', 'spec', 'Spec', False, False),
+        ('status', 'status', 'Status', False, False)
+    ]        
+
+    def __init__(self,
+                 apiVersion=_omit,  # type: Optional[str]
+                 kind=_omit,  # type: Optional[str]
+                 metadata=_omit,  # type: Optional[Metadata]
+                 spec=_omit,  # type: Optional[Spec]
+                 status=_omit,  # type: Optional[Status]
+                 ):
+        super(VolumeClaimTemplatesItem, self).__init__(
+            apiVersion=apiVersion,
+            kind=kind,
+            metadata=metadata,
+            spec=spec,
+            status=status,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Metadata
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Optional[Metadata]) -> None
+        self._metadata = new_val
+    
+    @property
+    def spec(self):
+        # type: () -> Spec
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Optional[Spec]) -> None
+        self._spec = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Status
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Status]) -> None
+        self._status = new_val
+
+
+class VolumeClaimTemplatesList(CrdObjectList):
+    _items_type = VolumeClaimTemplatesItem
+
+
+class NodesItem(CrdObject):
+    _properties = [
+        ('config', 'config', object, False, True),
+        ('deviceFilter', 'deviceFilter', str, False, False),
+        ('devicePathFilter', 'devicePathFilter', str, False, False),
+        ('devices', 'devices', 'DevicesList', False, True),
+        ('name', 'name', str, False, False),
+        ('resources', 'resources', 'Resources', False, True),
+        ('useAllDevices', 'useAllDevices', bool, False, False),
+        ('volumeClaimTemplates', 'volumeClaimTemplates', 'VolumeClaimTemplatesList', False, False)
+    ]        
+
+    def __init__(self,
+                 config=_omit,  # type: Optional[Any]
+                 deviceFilter=_omit,  # type: Optional[str]
+                 devicePathFilter=_omit,  # type: Optional[str]
+                 devices=_omit,  # type: Optional[Union[List[DevicesItem], CrdObjectList]]
+                 name=_omit,  # type: Optional[str]
+                 resources=_omit,  # type: Optional[Resources]
+                 useAllDevices=_omit,  # type: Optional[bool]
+                 volumeClaimTemplates=_omit,  # type: Optional[Union[List[VolumeClaimTemplatesItem], CrdObjectList]]
+                 ):
+        super(NodesItem, self).__init__(
+            config=config,
+            deviceFilter=deviceFilter,
+            devicePathFilter=devicePathFilter,
+            devices=devices,
+            name=name,
+            resources=resources,
+            useAllDevices=useAllDevices,
+            volumeClaimTemplates=volumeClaimTemplates,
+        )
+
+    @property
+    def config(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('config')
+    
+    @config.setter
+    def config(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._config = new_val
+    
+    @property
+    def deviceFilter(self):
+        # type: () -> str
+        return self._property_impl('deviceFilter')
+    
+    @deviceFilter.setter
+    def deviceFilter(self, new_val):
+        # type: (Optional[str]) -> None
+        self._deviceFilter = new_val
+    
+    @property
+    def devicePathFilter(self):
+        # type: () -> str
+        return self._property_impl('devicePathFilter')
+    
+    @devicePathFilter.setter
+    def devicePathFilter(self, new_val):
+        # type: (Optional[str]) -> None
+        self._devicePathFilter = new_val
+    
+    @property
+    def devices(self):
+        # type: () -> Optional[Union[List[DevicesItem], CrdObjectList]]
+        return self._property_impl('devices')
+    
+    @devices.setter
+    def devices(self, new_val):
+        # type: (Optional[Union[List[DevicesItem], CrdObjectList]]) -> None
+        self._devices = new_val
+    
+    @property
+    def name(self):
+        # type: () -> str
+        return self._property_impl('name')
+    
+    @name.setter
+    def name(self, new_val):
+        # type: (Optional[str]) -> None
+        self._name = new_val
+    
+    @property
+    def resources(self):
+        # type: () -> Optional[Resources]
+        return self._property_impl('resources')
+    
+    @resources.setter
+    def resources(self, new_val):
+        # type: (Optional[Resources]) -> None
+        self._resources = new_val
+    
+    @property
+    def useAllDevices(self):
+        # type: () -> bool
+        return self._property_impl('useAllDevices')
+    
+    @useAllDevices.setter
+    def useAllDevices(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._useAllDevices = new_val
+    
+    @property
+    def volumeClaimTemplates(self):
+        # type: () -> Union[List[VolumeClaimTemplatesItem], CrdObjectList]
+        return self._property_impl('volumeClaimTemplates')
+    
+    @volumeClaimTemplates.setter
+    def volumeClaimTemplates(self, new_val):
+        # type: (Optional[Union[List[VolumeClaimTemplatesItem], CrdObjectList]]) -> None
+        self._volumeClaimTemplates = new_val
+
+
+class NodesList(CrdObjectList):
+    _items_type = NodesItem
+
+
+class MatchFieldsItem(CrdObject):
+    _properties = [
+        ('key', 'key', str, True, False),
+        ('operator', 'operator', str, True, False),
+        ('values', 'values', 'ValuesList', False, False)
+    ]        
+
+    def __init__(self,
+                 key,  # type: str
+                 operator,  # type: str
+                 values=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(MatchFieldsItem, self).__init__(
+            key=key,
+            operator=operator,
+            values=values,
+        )
+
+    @property
+    def key(self):
+        # type: () -> str
+        return self._property_impl('key')
+    
+    @key.setter
+    def key(self, new_val):
+        # type: (str) -> None
+        self._key = new_val
+    
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._property_impl('operator')
+    
+    @operator.setter
+    def operator(self, new_val):
+        # type: (str) -> None
+        self._operator = new_val
+    
+    @property
+    def values(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('values')
+    
+    @values.setter
+    def values(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._values = new_val
+
+
+class MatchFieldsList(CrdObjectList):
+    _items_type = MatchFieldsItem
+
+
+class Preference(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchFields', 'matchFields', 'MatchFieldsList', False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchFields=_omit,  # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]]
+                 ):
+        super(Preference, self).__init__(
+            matchExpressions=matchExpressions,
+            matchFields=matchFields,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchFields(self):
+        # type: () -> Union[List[MatchFieldsItem], CrdObjectList]
+        return self._property_impl('matchFields')
+    
+    @matchFields.setter
+    def matchFields(self, new_val):
+        # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None
+        self._matchFields = new_val
+
+
+class PreferredDuringSchedulingIgnoredDuringExecutionItem(CrdObject):
+    _properties = [
+        ('podAffinityTerm', 'podAffinityTerm', 'PodAffinityTerm', False, False),
+        ('weight', 'weight', int, False, False),
+        ('preference', 'preference', 'Preference', False, False)
+    ]        
+
+    def __init__(self,
+                 podAffinityTerm=_omit,  # type: Optional[PodAffinityTerm]
+                 weight=_omit,  # type: Optional[int]
+                 preference=_omit,  # type: Optional[Preference]
+                 ):
+        super(PreferredDuringSchedulingIgnoredDuringExecutionItem, self).__init__(
+            podAffinityTerm=podAffinityTerm,
+            weight=weight,
+            preference=preference,
+        )
+
+    @property
+    def podAffinityTerm(self):
+        # type: () -> PodAffinityTerm
+        return self._property_impl('podAffinityTerm')
+    
+    @podAffinityTerm.setter
+    def podAffinityTerm(self, new_val):
+        # type: (Optional[PodAffinityTerm]) -> None
+        self._podAffinityTerm = new_val
+    
+    @property
+    def weight(self):
+        # type: () -> int
+        return self._property_impl('weight')
+    
+    @weight.setter
+    def weight(self, new_val):
+        # type: (Optional[int]) -> None
+        self._weight = new_val
+    
+    @property
+    def preference(self):
+        # type: () -> Preference
+        return self._property_impl('preference')
+    
+    @preference.setter
+    def preference(self, new_val):
+        # type: (Optional[Preference]) -> None
+        self._preference = new_val
+
+
+class PreferredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList):
+    _items_type = PreferredDuringSchedulingIgnoredDuringExecutionItem
+
+
+class NodeSelectorTermsItem(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchFields', 'matchFields', 'MatchFieldsList', False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchFields=_omit,  # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]]
+                 ):
+        super(NodeSelectorTermsItem, self).__init__(
+            matchExpressions=matchExpressions,
+            matchFields=matchFields,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchFields(self):
+        # type: () -> Union[List[MatchFieldsItem], CrdObjectList]
+        return self._property_impl('matchFields')
+    
+    @matchFields.setter
+    def matchFields(self, new_val):
+        # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None
+        self._matchFields = new_val
+
+
+class NodeSelectorTermsList(CrdObjectList):
+    _items_type = NodeSelectorTermsItem
+
+
+class RequiredDuringSchedulingIgnoredDuringExecution(CrdObject):
+    _properties = [
+        ('nodeSelectorTerms', 'nodeSelectorTerms', 'NodeSelectorTermsList', True, False)
+    ]        
+
+    def __init__(self,
+                 nodeSelectorTerms,  # type: Union[List[NodeSelectorTermsItem], CrdObjectList]
+                 ):
+        super(RequiredDuringSchedulingIgnoredDuringExecution, self).__init__(
+            nodeSelectorTerms=nodeSelectorTerms,
+        )
+
+    @property
+    def nodeSelectorTerms(self):
+        # type: () -> Union[List[NodeSelectorTermsItem], CrdObjectList]
+        return self._property_impl('nodeSelectorTerms')
+    
+    @nodeSelectorTerms.setter
+    def nodeSelectorTerms(self, new_val):
+        # type: (Union[List[NodeSelectorTermsItem], CrdObjectList]) -> None
+        self._nodeSelectorTerms = new_val
+
+
+class NodeAffinity(CrdObject):
+    _properties = [
+        ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False),
+        ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecution', False, False)
+    ]        
+
+    def __init__(self,
+                 preferredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 requiredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[RequiredDuringSchedulingIgnoredDuringExecution]
+                 ):
+        super(NodeAffinity, self).__init__(
+            preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution,
+            requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution,
+        )
+
+    @property
+    def preferredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution')
+    
+    @preferredDuringSchedulingIgnoredDuringExecution.setter
+    def preferredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._preferredDuringSchedulingIgnoredDuringExecution = new_val
+    
+    @property
+    def requiredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> RequiredDuringSchedulingIgnoredDuringExecution
+        return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution')
+    
+    @requiredDuringSchedulingIgnoredDuringExecution.setter
+    def requiredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[RequiredDuringSchedulingIgnoredDuringExecution]) -> None
+        self._requiredDuringSchedulingIgnoredDuringExecution = new_val
+
+
+class LabelSelector(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchLabels', 'matchLabels', object, False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchLabels=_omit,  # type: Optional[Any]
+                 ):
+        super(LabelSelector, self).__init__(
+            matchExpressions=matchExpressions,
+            matchLabels=matchLabels,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchLabels(self):
+        # type: () -> Any
+        return self._property_impl('matchLabels')
+    
+    @matchLabels.setter
+    def matchLabels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._matchLabels = new_val
+
+
+class NamespaceSelector(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchLabels', 'matchLabels', object, False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchLabels=_omit,  # type: Optional[Any]
+                 ):
+        super(NamespaceSelector, self).__init__(
+            matchExpressions=matchExpressions,
+            matchLabels=matchLabels,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchLabels(self):
+        # type: () -> Any
+        return self._property_impl('matchLabels')
+    
+    @matchLabels.setter
+    def matchLabels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._matchLabels = new_val
+
+
+class NamespacesList(CrdObjectList):
+    _items_type = str
+
+
+class PodAffinityTerm(CrdObject):
+    _properties = [
+        ('labelSelector', 'labelSelector', 'LabelSelector', False, False),
+        ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False),
+        ('namespaces', 'namespaces', 'NamespacesList', False, False),
+        ('topologyKey', 'topologyKey', str, True, False)
+    ]        
+
+    def __init__(self,
+                 topologyKey,  # type: str
+                 labelSelector=_omit,  # type: Optional[LabelSelector]
+                 namespaceSelector=_omit,  # type: Optional[NamespaceSelector]
+                 namespaces=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(PodAffinityTerm, self).__init__(
+            topologyKey=topologyKey,
+            labelSelector=labelSelector,
+            namespaceSelector=namespaceSelector,
+            namespaces=namespaces,
+        )
+
+    @property
+    def labelSelector(self):
+        # type: () -> LabelSelector
+        return self._property_impl('labelSelector')
+    
+    @labelSelector.setter
+    def labelSelector(self, new_val):
+        # type: (Optional[LabelSelector]) -> None
+        self._labelSelector = new_val
+    
+    @property
+    def namespaceSelector(self):
+        # type: () -> NamespaceSelector
+        return self._property_impl('namespaceSelector')
+    
+    @namespaceSelector.setter
+    def namespaceSelector(self, new_val):
+        # type: (Optional[NamespaceSelector]) -> None
+        self._namespaceSelector = new_val
+    
+    @property
+    def namespaces(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('namespaces')
+    
+    @namespaces.setter
+    def namespaces(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._namespaces = new_val
+    
+    @property
+    def topologyKey(self):
+        # type: () -> str
+        return self._property_impl('topologyKey')
+    
+    @topologyKey.setter
+    def topologyKey(self, new_val):
+        # type: (str) -> None
+        self._topologyKey = new_val
+
+
+class RequiredDuringSchedulingIgnoredDuringExecutionItem(CrdObject):
+    _properties = [
+        ('labelSelector', 'labelSelector', 'LabelSelector', False, False),
+        ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False),
+        ('namespaces', 'namespaces', 'NamespacesList', False, False),
+        ('topologyKey', 'topologyKey', str, True, False)
+    ]        
+
+    def __init__(self,
+                 topologyKey,  # type: str
+                 labelSelector=_omit,  # type: Optional[LabelSelector]
+                 namespaceSelector=_omit,  # type: Optional[NamespaceSelector]
+                 namespaces=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(RequiredDuringSchedulingIgnoredDuringExecutionItem, self).__init__(
+            topologyKey=topologyKey,
+            labelSelector=labelSelector,
+            namespaceSelector=namespaceSelector,
+            namespaces=namespaces,
+        )
+
+    @property
+    def labelSelector(self):
+        # type: () -> LabelSelector
+        return self._property_impl('labelSelector')
+    
+    @labelSelector.setter
+    def labelSelector(self, new_val):
+        # type: (Optional[LabelSelector]) -> None
+        self._labelSelector = new_val
+    
+    @property
+    def namespaceSelector(self):
+        # type: () -> NamespaceSelector
+        return self._property_impl('namespaceSelector')
+    
+    @namespaceSelector.setter
+    def namespaceSelector(self, new_val):
+        # type: (Optional[NamespaceSelector]) -> None
+        self._namespaceSelector = new_val
+    
+    @property
+    def namespaces(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('namespaces')
+    
+    @namespaces.setter
+    def namespaces(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._namespaces = new_val
+    
+    @property
+    def topologyKey(self):
+        # type: () -> str
+        return self._property_impl('topologyKey')
+    
+    @topologyKey.setter
+    def topologyKey(self, new_val):
+        # type: (str) -> None
+        self._topologyKey = new_val
+
+
+class RequiredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList):
+    _items_type = RequiredDuringSchedulingIgnoredDuringExecutionItem
+
+
+class PodAffinity(CrdObject):
+    _properties = [
+        ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False),
+        ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False)
+    ]        
+
+    def __init__(self,
+                 preferredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 requiredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 ):
+        super(PodAffinity, self).__init__(
+            preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution,
+            requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution,
+        )
+
+    @property
+    def preferredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution')
+    
+    @preferredDuringSchedulingIgnoredDuringExecution.setter
+    def preferredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._preferredDuringSchedulingIgnoredDuringExecution = new_val
+    
+    @property
+    def requiredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution')
+    
+    @requiredDuringSchedulingIgnoredDuringExecution.setter
+    def requiredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._requiredDuringSchedulingIgnoredDuringExecution = new_val
+
+
+class PodAntiAffinity(CrdObject):
+    _properties = [
+        ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False),
+        ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False)
+    ]        
+
+    def __init__(self,
+                 preferredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 requiredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 ):
+        super(PodAntiAffinity, self).__init__(
+            preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution,
+            requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution,
+        )
+
+    @property
+    def preferredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution')
+    
+    @preferredDuringSchedulingIgnoredDuringExecution.setter
+    def preferredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._preferredDuringSchedulingIgnoredDuringExecution = new_val
+    
+    @property
+    def requiredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution')
+    
+    @requiredDuringSchedulingIgnoredDuringExecution.setter
+    def requiredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._requiredDuringSchedulingIgnoredDuringExecution = new_val
+
+
+class TolerationsItem(CrdObject):
+    _properties = [
+        ('effect', 'effect', str, False, False),
+        ('key', 'key', str, False, False),
+        ('operator', 'operator', str, False, False),
+        ('tolerationSeconds', 'tolerationSeconds', int, False, False),
+        ('value', 'value', str, False, False)
+    ]        
+
+    def __init__(self,
+                 effect=_omit,  # type: Optional[str]
+                 key=_omit,  # type: Optional[str]
+                 operator=_omit,  # type: Optional[str]
+                 tolerationSeconds=_omit,  # type: Optional[int]
+                 value=_omit,  # type: Optional[str]
+                 ):
+        super(TolerationsItem, self).__init__(
+            effect=effect,
+            key=key,
+            operator=operator,
+            tolerationSeconds=tolerationSeconds,
+            value=value,
+        )
+
+    @property
+    def effect(self):
+        # type: () -> str
+        return self._property_impl('effect')
+    
+    @effect.setter
+    def effect(self, new_val):
+        # type: (Optional[str]) -> None
+        self._effect = new_val
+    
+    @property
+    def key(self):
+        # type: () -> str
+        return self._property_impl('key')
+    
+    @key.setter
+    def key(self, new_val):
+        # type: (Optional[str]) -> None
+        self._key = new_val
+    
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._property_impl('operator')
+    
+    @operator.setter
+    def operator(self, new_val):
+        # type: (Optional[str]) -> None
+        self._operator = new_val
+    
+    @property
+    def tolerationSeconds(self):
+        # type: () -> int
+        return self._property_impl('tolerationSeconds')
+    
+    @tolerationSeconds.setter
+    def tolerationSeconds(self, new_val):
+        # type: (Optional[int]) -> None
+        self._tolerationSeconds = new_val
+    
+    @property
+    def value(self):
+        # type: () -> str
+        return self._property_impl('value')
+    
+    @value.setter
+    def value(self, new_val):
+        # type: (Optional[str]) -> None
+        self._value = new_val
+
+
+class TolerationsList(CrdObjectList):
+    _items_type = TolerationsItem
+
+
+class TopologySpreadConstraintsItem(CrdObject):
+    _properties = [
+        ('labelSelector', 'labelSelector', 'LabelSelector', False, False),
+        ('maxSkew', 'maxSkew', int, True, False),
+        ('topologyKey', 'topologyKey', str, True, False),
+        ('whenUnsatisfiable', 'whenUnsatisfiable', str, True, False)
+    ]        
+
+    def __init__(self,
+                 maxSkew,  # type: int
+                 topologyKey,  # type: str
+                 whenUnsatisfiable,  # type: str
+                 labelSelector=_omit,  # type: Optional[LabelSelector]
+                 ):
+        super(TopologySpreadConstraintsItem, self).__init__(
+            maxSkew=maxSkew,
+            topologyKey=topologyKey,
+            whenUnsatisfiable=whenUnsatisfiable,
+            labelSelector=labelSelector,
+        )
+
+    @property
+    def labelSelector(self):
+        # type: () -> LabelSelector
+        return self._property_impl('labelSelector')
+    
+    @labelSelector.setter
+    def labelSelector(self, new_val):
+        # type: (Optional[LabelSelector]) -> None
+        self._labelSelector = new_val
+    
+    @property
+    def maxSkew(self):
+        # type: () -> int
+        return self._property_impl('maxSkew')
+    
+    @maxSkew.setter
+    def maxSkew(self, new_val):
+        # type: (int) -> None
+        self._maxSkew = new_val
+    
+    @property
+    def topologyKey(self):
+        # type: () -> str
+        return self._property_impl('topologyKey')
+    
+    @topologyKey.setter
+    def topologyKey(self, new_val):
+        # type: (str) -> None
+        self._topologyKey = new_val
+    
+    @property
+    def whenUnsatisfiable(self):
+        # type: () -> str
+        return self._property_impl('whenUnsatisfiable')
+    
+    @whenUnsatisfiable.setter
+    def whenUnsatisfiable(self, new_val):
+        # type: (str) -> None
+        self._whenUnsatisfiable = new_val
+
+
+class TopologySpreadConstraintsList(CrdObjectList):
+    _items_type = TopologySpreadConstraintsItem
+
+
+class Placement(CrdObject):
+    _properties = [
+        ('nodeAffinity', 'nodeAffinity', 'NodeAffinity', False, False),
+        ('podAffinity', 'podAffinity', 'PodAffinity', False, False),
+        ('podAntiAffinity', 'podAntiAffinity', 'PodAntiAffinity', False, False),
+        ('tolerations', 'tolerations', 'TolerationsList', False, False),
+        ('topologySpreadConstraints', 'topologySpreadConstraints', 'TopologySpreadConstraintsList', False, False)
+    ]        
+
+    def __init__(self,
+                 nodeAffinity=_omit,  # type: Optional[NodeAffinity]
+                 podAffinity=_omit,  # type: Optional[PodAffinity]
+                 podAntiAffinity=_omit,  # type: Optional[PodAntiAffinity]
+                 tolerations=_omit,  # type: Optional[Union[List[TolerationsItem], CrdObjectList]]
+                 topologySpreadConstraints=_omit,  # type: Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]
+                 ):
+        super(Placement, self).__init__(
+            nodeAffinity=nodeAffinity,
+            podAffinity=podAffinity,
+            podAntiAffinity=podAntiAffinity,
+            tolerations=tolerations,
+            topologySpreadConstraints=topologySpreadConstraints,
+        )
+
+    @property
+    def nodeAffinity(self):
+        # type: () -> NodeAffinity
+        return self._property_impl('nodeAffinity')
+    
+    @nodeAffinity.setter
+    def nodeAffinity(self, new_val):
+        # type: (Optional[NodeAffinity]) -> None
+        self._nodeAffinity = new_val
+    
+    @property
+    def podAffinity(self):
+        # type: () -> PodAffinity
+        return self._property_impl('podAffinity')
+    
+    @podAffinity.setter
+    def podAffinity(self, new_val):
+        # type: (Optional[PodAffinity]) -> None
+        self._podAffinity = new_val
+    
+    @property
+    def podAntiAffinity(self):
+        # type: () -> PodAntiAffinity
+        return self._property_impl('podAntiAffinity')
+    
+    @podAntiAffinity.setter
+    def podAntiAffinity(self, new_val):
+        # type: (Optional[PodAntiAffinity]) -> None
+        self._podAntiAffinity = new_val
+    
+    @property
+    def tolerations(self):
+        # type: () -> Union[List[TolerationsItem], CrdObjectList]
+        return self._property_impl('tolerations')
+    
+    @tolerations.setter
+    def tolerations(self, new_val):
+        # type: (Optional[Union[List[TolerationsItem], CrdObjectList]]) -> None
+        self._tolerations = new_val
+    
+    @property
+    def topologySpreadConstraints(self):
+        # type: () -> Union[List[TopologySpreadConstraintsItem], CrdObjectList]
+        return self._property_impl('topologySpreadConstraints')
+    
+    @topologySpreadConstraints.setter
+    def topologySpreadConstraints(self, new_val):
+        # type: (Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]) -> None
+        self._topologySpreadConstraints = new_val
+
+
+class PreparePlacement(CrdObject):
+    _properties = [
+        ('nodeAffinity', 'nodeAffinity', 'NodeAffinity', False, False),
+        ('podAffinity', 'podAffinity', 'PodAffinity', False, False),
+        ('podAntiAffinity', 'podAntiAffinity', 'PodAntiAffinity', False, False),
+        ('tolerations', 'tolerations', 'TolerationsList', False, False),
+        ('topologySpreadConstraints', 'topologySpreadConstraints', 'TopologySpreadConstraintsList', False, False)
+    ]        
+
+    def __init__(self,
+                 nodeAffinity=_omit,  # type: Optional[NodeAffinity]
+                 podAffinity=_omit,  # type: Optional[PodAffinity]
+                 podAntiAffinity=_omit,  # type: Optional[PodAntiAffinity]
+                 tolerations=_omit,  # type: Optional[Union[List[TolerationsItem], CrdObjectList]]
+                 topologySpreadConstraints=_omit,  # type: Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]
+                 ):
+        super(PreparePlacement, self).__init__(
+            nodeAffinity=nodeAffinity,
+            podAffinity=podAffinity,
+            podAntiAffinity=podAntiAffinity,
+            tolerations=tolerations,
+            topologySpreadConstraints=topologySpreadConstraints,
+        )
+
+    @property
+    def nodeAffinity(self):
+        # type: () -> NodeAffinity
+        return self._property_impl('nodeAffinity')
+    
+    @nodeAffinity.setter
+    def nodeAffinity(self, new_val):
+        # type: (Optional[NodeAffinity]) -> None
+        self._nodeAffinity = new_val
+    
+    @property
+    def podAffinity(self):
+        # type: () -> PodAffinity
+        return self._property_impl('podAffinity')
+    
+    @podAffinity.setter
+    def podAffinity(self, new_val):
+        # type: (Optional[PodAffinity]) -> None
+        self._podAffinity = new_val
+    
+    @property
+    def podAntiAffinity(self):
+        # type: () -> PodAntiAffinity
+        return self._property_impl('podAntiAffinity')
+    
+    @podAntiAffinity.setter
+    def podAntiAffinity(self, new_val):
+        # type: (Optional[PodAntiAffinity]) -> None
+        self._podAntiAffinity = new_val
+    
+    @property
+    def tolerations(self):
+        # type: () -> Union[List[TolerationsItem], CrdObjectList]
+        return self._property_impl('tolerations')
+    
+    @tolerations.setter
+    def tolerations(self, new_val):
+        # type: (Optional[Union[List[TolerationsItem], CrdObjectList]]) -> None
+        self._tolerations = new_val
+    
+    @property
+    def topologySpreadConstraints(self):
+        # type: () -> Union[List[TopologySpreadConstraintsItem], CrdObjectList]
+        return self._property_impl('topologySpreadConstraints')
+    
+    @topologySpreadConstraints.setter
+    def topologySpreadConstraints(self, new_val):
+        # type: (Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]) -> None
+        self._topologySpreadConstraints = new_val
+
+
+class StorageClassDeviceSetsItem(CrdObject):
+    _properties = [
+        ('config', 'config', object, False, True),
+        ('count', 'count', int, True, False),
+        ('encrypted', 'encrypted', bool, False, False),
+        ('name', 'name', str, True, False),
+        ('placement', 'placement', 'Placement', False, True),
+        ('portable', 'portable', bool, False, False),
+        ('preparePlacement', 'preparePlacement', 'PreparePlacement', False, True),
+        ('resources', 'resources', 'Resources', False, True),
+        ('schedulerName', 'schedulerName', str, False, False),
+        ('tuneDeviceClass', 'tuneDeviceClass', bool, False, False),
+        ('tuneFastDeviceClass', 'tuneFastDeviceClass', bool, False, False),
+        ('volumeClaimTemplates', 'volumeClaimTemplates', 'VolumeClaimTemplatesList', True, False)
+    ]        
+
+    def __init__(self,
+                 count,  # type: int
+                 name,  # type: str
+                 volumeClaimTemplates,  # type: Union[List[VolumeClaimTemplatesItem], CrdObjectList]
+                 config=_omit,  # type: Optional[Any]
+                 encrypted=_omit,  # type: Optional[bool]
+                 placement=_omit,  # type: Optional[Placement]
+                 portable=_omit,  # type: Optional[bool]
+                 preparePlacement=_omit,  # type: Optional[PreparePlacement]
+                 resources=_omit,  # type: Optional[Resources]
+                 schedulerName=_omit,  # type: Optional[str]
+                 tuneDeviceClass=_omit,  # type: Optional[bool]
+                 tuneFastDeviceClass=_omit,  # type: Optional[bool]
+                 ):
+        super(StorageClassDeviceSetsItem, self).__init__(
+            count=count,
+            name=name,
+            volumeClaimTemplates=volumeClaimTemplates,
+            config=config,
+            encrypted=encrypted,
+            placement=placement,
+            portable=portable,
+            preparePlacement=preparePlacement,
+            resources=resources,
+            schedulerName=schedulerName,
+            tuneDeviceClass=tuneDeviceClass,
+            tuneFastDeviceClass=tuneFastDeviceClass,
+        )
+
+    @property
+    def config(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('config')
+    
+    @config.setter
+    def config(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._config = new_val
+    
+    @property
+    def count(self):
+        # type: () -> int
+        return self._property_impl('count')
+    
+    @count.setter
+    def count(self, new_val):
+        # type: (int) -> None
+        self._count = new_val
+    
+    @property
+    def encrypted(self):
+        # type: () -> bool
+        return self._property_impl('encrypted')
+    
+    @encrypted.setter
+    def encrypted(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._encrypted = new_val
+    
+    @property
+    def name(self):
+        # type: () -> str
+        return self._property_impl('name')
+    
+    @name.setter
+    def name(self, new_val):
+        # type: (str) -> None
+        self._name = new_val
+    
+    @property
+    def placement(self):
+        # type: () -> Optional[Placement]
+        return self._property_impl('placement')
+    
+    @placement.setter
+    def placement(self, new_val):
+        # type: (Optional[Placement]) -> None
+        self._placement = new_val
+    
+    @property
+    def portable(self):
+        # type: () -> bool
+        return self._property_impl('portable')
+    
+    @portable.setter
+    def portable(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._portable = new_val
+    
+    @property
+    def preparePlacement(self):
+        # type: () -> Optional[PreparePlacement]
+        return self._property_impl('preparePlacement')
+    
+    @preparePlacement.setter
+    def preparePlacement(self, new_val):
+        # type: (Optional[PreparePlacement]) -> None
+        self._preparePlacement = new_val
+    
+    @property
+    def resources(self):
+        # type: () -> Optional[Resources]
+        return self._property_impl('resources')
+    
+    @resources.setter
+    def resources(self, new_val):
+        # type: (Optional[Resources]) -> None
+        self._resources = new_val
+    
+    @property
+    def schedulerName(self):
+        # type: () -> str
+        return self._property_impl('schedulerName')
+    
+    @schedulerName.setter
+    def schedulerName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._schedulerName = new_val
+    
+    @property
+    def tuneDeviceClass(self):
+        # type: () -> bool
+        return self._property_impl('tuneDeviceClass')
+    
+    @tuneDeviceClass.setter
+    def tuneDeviceClass(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._tuneDeviceClass = new_val
+    
+    @property
+    def tuneFastDeviceClass(self):
+        # type: () -> bool
+        return self._property_impl('tuneFastDeviceClass')
+    
+    @tuneFastDeviceClass.setter
+    def tuneFastDeviceClass(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._tuneFastDeviceClass = new_val
+    
+    @property
+    def volumeClaimTemplates(self):
+        # type: () -> Union[List[VolumeClaimTemplatesItem], CrdObjectList]
+        return self._property_impl('volumeClaimTemplates')
+    
+    @volumeClaimTemplates.setter
+    def volumeClaimTemplates(self, new_val):
+        # type: (Union[List[VolumeClaimTemplatesItem], CrdObjectList]) -> None
+        self._volumeClaimTemplates = new_val
+
+
+class StorageClassDeviceSetsList(CrdObjectList):
+    _items_type = StorageClassDeviceSetsItem
+
+
+class Storage(CrdObject):
+    _properties = [
+        ('deviceClasses', 'deviceClasses', 'DeviceClassesList', False, False),
+        ('config', 'config', object, False, True),
+        ('deviceFilter', 'deviceFilter', str, False, False),
+        ('devicePathFilter', 'devicePathFilter', str, False, False),
+        ('devices', 'devices', 'DevicesList', False, True),
+        ('nodes', 'nodes', 'NodesList', False, True),
+        ('storageClassDeviceSets', 'storageClassDeviceSets', 'StorageClassDeviceSetsList', False, True),
+        ('useAllDevices', 'useAllDevices', bool, False, False),
+        ('useAllNodes', 'useAllNodes', bool, False, False),
+        ('volumeClaimTemplates', 'volumeClaimTemplates', 'VolumeClaimTemplatesList', False, False)
+    ]        
+
+    def __init__(self,
+                 deviceClasses=_omit,  # type: Optional[Union[List[DeviceClassesItem], CrdObjectList]]
+                 config=_omit,  # type: Optional[Any]
+                 deviceFilter=_omit,  # type: Optional[str]
+                 devicePathFilter=_omit,  # type: Optional[str]
+                 devices=_omit,  # type: Optional[Union[List[DevicesItem], CrdObjectList]]
+                 nodes=_omit,  # type: Optional[Union[List[NodesItem], CrdObjectList]]
+                 storageClassDeviceSets=_omit,  # type: Optional[Union[List[StorageClassDeviceSetsItem], CrdObjectList]]
+                 useAllDevices=_omit,  # type: Optional[bool]
+                 useAllNodes=_omit,  # type: Optional[bool]
+                 volumeClaimTemplates=_omit,  # type: Optional[Union[List[VolumeClaimTemplatesItem], CrdObjectList]]
+                 ):
+        super(Storage, self).__init__(
+            deviceClasses=deviceClasses,
+            config=config,
+            deviceFilter=deviceFilter,
+            devicePathFilter=devicePathFilter,
+            devices=devices,
+            nodes=nodes,
+            storageClassDeviceSets=storageClassDeviceSets,
+            useAllDevices=useAllDevices,
+            useAllNodes=useAllNodes,
+            volumeClaimTemplates=volumeClaimTemplates,
+        )
+
+    @property
+    def deviceClasses(self):
+        # type: () -> Union[List[DeviceClassesItem], CrdObjectList]
+        return self._property_impl('deviceClasses')
+    
+    @deviceClasses.setter
+    def deviceClasses(self, new_val):
+        # type: (Optional[Union[List[DeviceClassesItem], CrdObjectList]]) -> None
+        self._deviceClasses = new_val
+    
+    @property
+    def config(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('config')
+    
+    @config.setter
+    def config(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._config = new_val
+    
+    @property
+    def deviceFilter(self):
+        # type: () -> str
+        return self._property_impl('deviceFilter')
+    
+    @deviceFilter.setter
+    def deviceFilter(self, new_val):
+        # type: (Optional[str]) -> None
+        self._deviceFilter = new_val
+    
+    @property
+    def devicePathFilter(self):
+        # type: () -> str
+        return self._property_impl('devicePathFilter')
+    
+    @devicePathFilter.setter
+    def devicePathFilter(self, new_val):
+        # type: (Optional[str]) -> None
+        self._devicePathFilter = new_val
+    
+    @property
+    def devices(self):
+        # type: () -> Optional[Union[List[DevicesItem], CrdObjectList]]
+        return self._property_impl('devices')
+    
+    @devices.setter
+    def devices(self, new_val):
+        # type: (Optional[Union[List[DevicesItem], CrdObjectList]]) -> None
+        self._devices = new_val
+    
+    @property
+    def nodes(self):
+        # type: () -> Optional[Union[List[NodesItem], CrdObjectList]]
+        return self._property_impl('nodes')
+    
+    @nodes.setter
+    def nodes(self, new_val):
+        # type: (Optional[Union[List[NodesItem], CrdObjectList]]) -> None
+        self._nodes = new_val
+    
+    @property
+    def storageClassDeviceSets(self):
+        # type: () -> Optional[Union[List[StorageClassDeviceSetsItem], CrdObjectList]]
+        return self._property_impl('storageClassDeviceSets')
+    
+    @storageClassDeviceSets.setter
+    def storageClassDeviceSets(self, new_val):
+        # type: (Optional[Union[List[StorageClassDeviceSetsItem], CrdObjectList]]) -> None
+        self._storageClassDeviceSets = new_val
+    
+    @property
+    def useAllDevices(self):
+        # type: () -> bool
+        return self._property_impl('useAllDevices')
+    
+    @useAllDevices.setter
+    def useAllDevices(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._useAllDevices = new_val
+    
+    @property
+    def useAllNodes(self):
+        # type: () -> bool
+        return self._property_impl('useAllNodes')
+    
+    @useAllNodes.setter
+    def useAllNodes(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._useAllNodes = new_val
+    
+    @property
+    def volumeClaimTemplates(self):
+        # type: () -> Union[List[VolumeClaimTemplatesItem], CrdObjectList]
+        return self._property_impl('volumeClaimTemplates')
+    
+    @volumeClaimTemplates.setter
+    def volumeClaimTemplates(self, new_val):
+        # type: (Optional[Union[List[VolumeClaimTemplatesItem], CrdObjectList]]) -> None
+        self._volumeClaimTemplates = new_val
+
+
+class Capacity(CrdObject):
+    _properties = [
+        ('bytesAvailable', 'bytesAvailable', int, False, False),
+        ('bytesTotal', 'bytesTotal', int, False, False),
+        ('bytesUsed', 'bytesUsed', int, False, False),
+        ('lastUpdated', 'lastUpdated', str, False, False)
+    ]        
+
+    def __init__(self,
+                 bytesAvailable=_omit,  # type: Optional[int]
+                 bytesTotal=_omit,  # type: Optional[int]
+                 bytesUsed=_omit,  # type: Optional[int]
+                 lastUpdated=_omit,  # type: Optional[str]
+                 ):
+        super(Capacity, self).__init__(
+            bytesAvailable=bytesAvailable,
+            bytesTotal=bytesTotal,
+            bytesUsed=bytesUsed,
+            lastUpdated=lastUpdated,
+        )
+
+    @property
+    def bytesAvailable(self):
+        # type: () -> int
+        return self._property_impl('bytesAvailable')
+    
+    @bytesAvailable.setter
+    def bytesAvailable(self, new_val):
+        # type: (Optional[int]) -> None
+        self._bytesAvailable = new_val
+    
+    @property
+    def bytesTotal(self):
+        # type: () -> int
+        return self._property_impl('bytesTotal')
+    
+    @bytesTotal.setter
+    def bytesTotal(self, new_val):
+        # type: (Optional[int]) -> None
+        self._bytesTotal = new_val
+    
+    @property
+    def bytesUsed(self):
+        # type: () -> int
+        return self._property_impl('bytesUsed')
+    
+    @bytesUsed.setter
+    def bytesUsed(self, new_val):
+        # type: (Optional[int]) -> None
+        self._bytesUsed = new_val
+    
+    @property
+    def lastUpdated(self):
+        # type: () -> str
+        return self._property_impl('lastUpdated')
+    
+    @lastUpdated.setter
+    def lastUpdated(self, new_val):
+        # type: (Optional[str]) -> None
+        self._lastUpdated = new_val
+
+
+class Versions(CrdObject):
+    _properties = [
+        ('cephfs-mirror', 'cephfs_mirror', object, False, False),
+        ('mds', 'mds', object, False, False),
+        ('mgr', 'mgr', object, False, False),
+        ('mon', 'mon', object, False, False),
+        ('osd', 'osd', object, False, False),
+        ('overall', 'overall', object, False, False),
+        ('rbd-mirror', 'rbd_mirror', object, False, False),
+        ('rgw', 'rgw', object, False, False)
+    ]        
+
+    def __init__(self,
+                 cephfs_mirror=_omit,  # type: Optional[Any]
+                 mds=_omit,  # type: Optional[Any]
+                 mgr=_omit,  # type: Optional[Any]
+                 mon=_omit,  # type: Optional[Any]
+                 osd=_omit,  # type: Optional[Any]
+                 overall=_omit,  # type: Optional[Any]
+                 rbd_mirror=_omit,  # type: Optional[Any]
+                 rgw=_omit,  # type: Optional[Any]
+                 ):
+        super(Versions, self).__init__(
+            cephfs_mirror=cephfs_mirror,
+            mds=mds,
+            mgr=mgr,
+            mon=mon,
+            osd=osd,
+            overall=overall,
+            rbd_mirror=rbd_mirror,
+            rgw=rgw,
+        )
+
+    @property
+    def cephfs_mirror(self):
+        # type: () -> Any
+        return self._property_impl('cephfs_mirror')
+    
+    @cephfs_mirror.setter
+    def cephfs_mirror(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._cephfs_mirror = new_val
+    
+    @property
+    def mds(self):
+        # type: () -> Any
+        return self._property_impl('mds')
+    
+    @mds.setter
+    def mds(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._mds = new_val
+    
+    @property
+    def mgr(self):
+        # type: () -> Any
+        return self._property_impl('mgr')
+    
+    @mgr.setter
+    def mgr(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._mgr = new_val
+    
+    @property
+    def mon(self):
+        # type: () -> Any
+        return self._property_impl('mon')
+    
+    @mon.setter
+    def mon(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._mon = new_val
+    
+    @property
+    def osd(self):
+        # type: () -> Any
+        return self._property_impl('osd')
+    
+    @osd.setter
+    def osd(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._osd = new_val
+    
+    @property
+    def overall(self):
+        # type: () -> Any
+        return self._property_impl('overall')
+    
+    @overall.setter
+    def overall(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._overall = new_val
+    
+    @property
+    def rbd_mirror(self):
+        # type: () -> Any
+        return self._property_impl('rbd_mirror')
+    
+    @rbd_mirror.setter
+    def rbd_mirror(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._rbd_mirror = new_val
+    
+    @property
+    def rgw(self):
+        # type: () -> Any
+        return self._property_impl('rgw')
+    
+    @rgw.setter
+    def rgw(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._rgw = new_val
+
+
+class Ceph(CrdObject):
+    _properties = [
+        ('capacity', 'capacity', 'Capacity', False, False),
+        ('details', 'details', object, False, False),
+        ('health', 'health', str, False, False),
+        ('lastChanged', 'lastChanged', str, False, False),
+        ('lastChecked', 'lastChecked', str, False, False),
+        ('previousHealth', 'previousHealth', str, False, False),
+        ('versions', 'versions', 'Versions', False, False)
+    ]        
+
+    def __init__(self,
+                 capacity=_omit,  # type: Optional[Capacity]
+                 details=_omit,  # type: Optional[Any]
+                 health=_omit,  # type: Optional[str]
+                 lastChanged=_omit,  # type: Optional[str]
+                 lastChecked=_omit,  # type: Optional[str]
+                 previousHealth=_omit,  # type: Optional[str]
+                 versions=_omit,  # type: Optional[Versions]
+                 ):
+        super(Ceph, self).__init__(
+            capacity=capacity,
+            details=details,
+            health=health,
+            lastChanged=lastChanged,
+            lastChecked=lastChecked,
+            previousHealth=previousHealth,
+            versions=versions,
+        )
+
+    @property
+    def capacity(self):
+        # type: () -> Capacity
+        return self._property_impl('capacity')
+    
+    @capacity.setter
+    def capacity(self, new_val):
+        # type: (Optional[Capacity]) -> None
+        self._capacity = new_val
+    
+    @property
+    def details(self):
+        # type: () -> Any
+        return self._property_impl('details')
+    
+    @details.setter
+    def details(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._details = new_val
+    
+    @property
+    def health(self):
+        # type: () -> str
+        return self._property_impl('health')
+    
+    @health.setter
+    def health(self, new_val):
+        # type: (Optional[str]) -> None
+        self._health = new_val
+    
+    @property
+    def lastChanged(self):
+        # type: () -> str
+        return self._property_impl('lastChanged')
+    
+    @lastChanged.setter
+    def lastChanged(self, new_val):
+        # type: (Optional[str]) -> None
+        self._lastChanged = new_val
+    
+    @property
+    def lastChecked(self):
+        # type: () -> str
+        return self._property_impl('lastChecked')
+    
+    @lastChecked.setter
+    def lastChecked(self, new_val):
+        # type: (Optional[str]) -> None
+        self._lastChecked = new_val
+    
+    @property
+    def previousHealth(self):
+        # type: () -> str
+        return self._property_impl('previousHealth')
+    
+    @previousHealth.setter
+    def previousHealth(self, new_val):
+        # type: (Optional[str]) -> None
+        self._previousHealth = new_val
+    
+    @property
+    def versions(self):
+        # type: () -> Versions
+        return self._property_impl('versions')
+    
+    @versions.setter
+    def versions(self, new_val):
+        # type: (Optional[Versions]) -> None
+        self._versions = new_val
+
+
+class DeviceClassesItem(CrdObject):
+    _properties = [
+        ('name', 'name', str, False, False)
+    ]        
+
+    def __init__(self,
+                 name=_omit,  # type: Optional[str]
+                 ):
+        super(DeviceClassesItem, self).__init__(
+            name=name,
+        )
+
+    @property
+    def name(self):
+        # type: () -> str
+        return self._property_impl('name')
+    
+    @name.setter
+    def name(self, new_val):
+        # type: (Optional[str]) -> None
+        self._name = new_val
+
+
+class DeviceClassesList(CrdObjectList):
+    _items_type = DeviceClassesItem
+
+
+class Version(CrdObject):
+    _properties = [
+        ('image', 'image', str, False, False),
+        ('version', 'version', str, False, False)
+    ]        
+
+    def __init__(self,
+                 image=_omit,  # type: Optional[str]
+                 version=_omit,  # type: Optional[str]
+                 ):
+        super(Version, self).__init__(
+            image=image,
+            version=version,
+        )
+
+    @property
+    def image(self):
+        # type: () -> str
+        return self._property_impl('image')
+    
+    @image.setter
+    def image(self, new_val):
+        # type: (Optional[str]) -> None
+        self._image = new_val
+    
+    @property
+    def version(self):
+        # type: () -> str
+        return self._property_impl('version')
+    
+    @version.setter
+    def version(self, new_val):
+        # type: (Optional[str]) -> None
+        self._version = new_val
+
+
+class CephCluster(CrdClass):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('kind', 'kind', str, False, False),
+        ('metadata', 'metadata', object, False, False),
+        ('spec', 'spec', 'Spec', True, False),
+        ('status', 'status', 'Status', False, True)
+    ]        
+
+    def __init__(self,
+                 spec,  # type: Spec
+                 apiVersion=_omit,  # type: Optional[str]
+                 kind=_omit,  # type: Optional[str]
+                 metadata=_omit,  # type: Optional[Any]
+                 status=_omit,  # type: Optional[Status]
+                 ):
+        super(CephCluster, self).__init__(
+            spec=spec,
+            apiVersion=apiVersion,
+            kind=kind,
+            metadata=metadata,
+            status=status,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Any
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._metadata = new_val
+    
+    @property
+    def spec(self):
+        # type: () -> Spec
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Spec) -> None
+        self._spec = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Optional[Status]
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Status]) -> None
+        self._status = new_val
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephfilesystem.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephfilesystem.py
new file mode 100644
index 000000000..c1eaa6dbc
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephfilesystem.py
@@ -0,0 +1,1771 @@
+"""
+This file is automatically generated.
+Do not modify.
+"""
+
+try:
+    from typing import Any, Optional, Union, List
+except ImportError:
+    pass
+
+from .._helper import _omit, CrdObject, CrdObjectList, CrdClass
+
+class ErasureCoded(CrdObject):
+    _properties = [
+        ('algorithm', 'algorithm', str, False, False),
+        ('codingChunks', 'codingChunks', int, True, False),
+        ('dataChunks', 'dataChunks', int, True, False)
+    ]        
+
+    def __init__(self,
+                 codingChunks,  # type: int
+                 dataChunks,  # type: int
+                 algorithm=_omit,  # type: Optional[str]
+                 ):
+        super(ErasureCoded, self).__init__(
+            codingChunks=codingChunks,
+            dataChunks=dataChunks,
+            algorithm=algorithm,
+        )
+
+    @property
+    def algorithm(self):
+        # type: () -> str
+        return self._property_impl('algorithm')
+    
+    @algorithm.setter
+    def algorithm(self, new_val):
+        # type: (Optional[str]) -> None
+        self._algorithm = new_val
+    
+    @property
+    def codingChunks(self):
+        # type: () -> int
+        return self._property_impl('codingChunks')
+    
+    @codingChunks.setter
+    def codingChunks(self, new_val):
+        # type: (int) -> None
+        self._codingChunks = new_val
+    
+    @property
+    def dataChunks(self):
+        # type: () -> int
+        return self._property_impl('dataChunks')
+    
+    @dataChunks.setter
+    def dataChunks(self, new_val):
+        # type: (int) -> None
+        self._dataChunks = new_val
+
+
+class SnapshotSchedulesItem(CrdObject):
+    _properties = [
+        ('interval', 'interval', str, False, False),
+        ('startTime', 'startTime', str, False, False)
+    ]        
+
+    def __init__(self,
+                 interval=_omit,  # type: Optional[str]
+                 startTime=_omit,  # type: Optional[str]
+                 ):
+        super(SnapshotSchedulesItem, self).__init__(
+            interval=interval,
+            startTime=startTime,
+        )
+
+    @property
+    def interval(self):
+        # type: () -> str
+        return self._property_impl('interval')
+    
+    @interval.setter
+    def interval(self, new_val):
+        # type: (Optional[str]) -> None
+        self._interval = new_val
+    
+    @property
+    def startTime(self):
+        # type: () -> str
+        return self._property_impl('startTime')
+    
+    @startTime.setter
+    def startTime(self, new_val):
+        # type: (Optional[str]) -> None
+        self._startTime = new_val
+
+
+class SnapshotSchedulesList(CrdObjectList):
+    _items_type = SnapshotSchedulesItem
+
+
+class Mirroring(CrdObject):
+    _properties = [
+        ('enabled', 'enabled', bool, False, False),
+        ('mode', 'mode', str, False, False),
+        ('snapshotSchedules', 'snapshotSchedules', 'SnapshotSchedulesList', False, False)
+    ]        
+
+    def __init__(self,
+                 enabled=_omit,  # type: Optional[bool]
+                 mode=_omit,  # type: Optional[str]
+                 snapshotSchedules=_omit,  # type: Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]]
+                 ):
+        super(Mirroring, self).__init__(
+            enabled=enabled,
+            mode=mode,
+            snapshotSchedules=snapshotSchedules,
+        )
+
+    @property
+    def enabled(self):
+        # type: () -> bool
+        return self._property_impl('enabled')
+    
+    @enabled.setter
+    def enabled(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._enabled = new_val
+    
+    @property
+    def mode(self):
+        # type: () -> str
+        return self._property_impl('mode')
+    
+    @mode.setter
+    def mode(self, new_val):
+        # type: (Optional[str]) -> None
+        self._mode = new_val
+    
+    @property
+    def snapshotSchedules(self):
+        # type: () -> Union[List[SnapshotSchedulesItem], CrdObjectList]
+        return self._property_impl('snapshotSchedules')
+    
+    @snapshotSchedules.setter
+    def snapshotSchedules(self, new_val):
+        # type: (Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]]) -> None
+        self._snapshotSchedules = new_val
+
+
+class Quotas(CrdObject):
+    _properties = [
+        ('maxBytes', 'maxBytes', int, False, False),
+        ('maxObjects', 'maxObjects', int, False, False),
+        ('maxSize', 'maxSize', str, False, False)
+    ]        
+
+    def __init__(self,
+                 maxBytes=_omit,  # type: Optional[int]
+                 maxObjects=_omit,  # type: Optional[int]
+                 maxSize=_omit,  # type: Optional[str]
+                 ):
+        super(Quotas, self).__init__(
+            maxBytes=maxBytes,
+            maxObjects=maxObjects,
+            maxSize=maxSize,
+        )
+
+    @property
+    def maxBytes(self):
+        # type: () -> int
+        return self._property_impl('maxBytes')
+    
+    @maxBytes.setter
+    def maxBytes(self, new_val):
+        # type: (Optional[int]) -> None
+        self._maxBytes = new_val
+    
+    @property
+    def maxObjects(self):
+        # type: () -> int
+        return self._property_impl('maxObjects')
+    
+    @maxObjects.setter
+    def maxObjects(self, new_val):
+        # type: (Optional[int]) -> None
+        self._maxObjects = new_val
+    
+    @property
+    def maxSize(self):
+        # type: () -> str
+        return self._property_impl('maxSize')
+    
+    @maxSize.setter
+    def maxSize(self, new_val):
+        # type: (Optional[str]) -> None
+        self._maxSize = new_val
+
+
+class Replicated(CrdObject):
+    _properties = [
+        ('replicasPerFailureDomain', 'replicasPerFailureDomain', int, False, False),
+        ('requireSafeReplicaSize', 'requireSafeReplicaSize', bool, False, False),
+        ('size', 'size', int, True, False),
+        ('subFailureDomain', 'subFailureDomain', str, False, False),
+        ('targetSizeRatio', 'targetSizeRatio', float, False, False)
+    ]        
+
+    def __init__(self,
+                 size,  # type: int
+                 replicasPerFailureDomain=_omit,  # type: Optional[int]
+                 requireSafeReplicaSize=_omit,  # type: Optional[bool]
+                 subFailureDomain=_omit,  # type: Optional[str]
+                 targetSizeRatio=_omit,  # type: Optional[float]
+                 ):
+        super(Replicated, self).__init__(
+            size=size,
+            replicasPerFailureDomain=replicasPerFailureDomain,
+            requireSafeReplicaSize=requireSafeReplicaSize,
+            subFailureDomain=subFailureDomain,
+            targetSizeRatio=targetSizeRatio,
+        )
+
+    @property
+    def replicasPerFailureDomain(self):
+        # type: () -> int
+        return self._property_impl('replicasPerFailureDomain')
+    
+    @replicasPerFailureDomain.setter
+    def replicasPerFailureDomain(self, new_val):
+        # type: (Optional[int]) -> None
+        self._replicasPerFailureDomain = new_val
+    
+    @property
+    def requireSafeReplicaSize(self):
+        # type: () -> bool
+        return self._property_impl('requireSafeReplicaSize')
+    
+    @requireSafeReplicaSize.setter
+    def requireSafeReplicaSize(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._requireSafeReplicaSize = new_val
+    
+    @property
+    def size(self):
+        # type: () -> int
+        return self._property_impl('size')
+    
+    @size.setter
+    def size(self, new_val):
+        # type: (int) -> None
+        self._size = new_val
+    
+    @property
+    def subFailureDomain(self):
+        # type: () -> str
+        return self._property_impl('subFailureDomain')
+    
+    @subFailureDomain.setter
+    def subFailureDomain(self, new_val):
+        # type: (Optional[str]) -> None
+        self._subFailureDomain = new_val
+    
+    @property
+    def targetSizeRatio(self):
+        # type: () -> float
+        return self._property_impl('targetSizeRatio')
+    
+    @targetSizeRatio.setter
+    def targetSizeRatio(self, new_val):
+        # type: (Optional[float]) -> None
+        self._targetSizeRatio = new_val
+
+
+class Mirror(CrdObject):
+    _properties = [
+        ('disabled', 'disabled', bool, False, False),
+        ('interval', 'interval', str, False, False),
+        ('timeout', 'timeout', str, False, False)
+    ]        
+
+    def __init__(self,
+                 disabled=_omit,  # type: Optional[bool]
+                 interval=_omit,  # type: Optional[str]
+                 timeout=_omit,  # type: Optional[str]
+                 ):
+        super(Mirror, self).__init__(
+            disabled=disabled,
+            interval=interval,
+            timeout=timeout,
+        )
+
+    @property
+    def disabled(self):
+        # type: () -> bool
+        return self._property_impl('disabled')
+    
+    @disabled.setter
+    def disabled(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._disabled = new_val
+    
+    @property
+    def interval(self):
+        # type: () -> str
+        return self._property_impl('interval')
+    
+    @interval.setter
+    def interval(self, new_val):
+        # type: (Optional[str]) -> None
+        self._interval = new_val
+    
+    @property
+    def timeout(self):
+        # type: () -> str
+        return self._property_impl('timeout')
+    
+    @timeout.setter
+    def timeout(self, new_val):
+        # type: (Optional[str]) -> None
+        self._timeout = new_val
+
+
+class StatusCheck(CrdObject):
+    _properties = [
+        ('mirror', 'mirror', 'Mirror', False, True)
+    ]        
+
+    def __init__(self,
+                 mirror=_omit,  # type: Optional[Mirror]
+                 ):
+        super(StatusCheck, self).__init__(
+            mirror=mirror,
+        )
+
+    @property
+    def mirror(self):
+        # type: () -> Optional[Mirror]
+        return self._property_impl('mirror')
+    
+    @mirror.setter
+    def mirror(self, new_val):
+        # type: (Optional[Mirror]) -> None
+        self._mirror = new_val
+
+
+class DataPoolsItem(CrdObject):
+    _properties = [
+        ('compressionMode', 'compressionMode', str, False, True),
+        ('crushRoot', 'crushRoot', str, False, True),
+        ('deviceClass', 'deviceClass', str, False, True),
+        ('enableRBDStats', 'enableRBDStats', bool, False, False),
+        ('erasureCoded', 'erasureCoded', 'ErasureCoded', False, False),
+        ('failureDomain', 'failureDomain', str, False, False),
+        ('mirroring', 'mirroring', 'Mirroring', False, False),
+        ('parameters', 'parameters', object, False, True),
+        ('quotas', 'quotas', 'Quotas', False, True),
+        ('replicated', 'replicated', 'Replicated', False, False),
+        ('statusCheck', 'statusCheck', 'StatusCheck', False, False)
+    ]        
+
+    def __init__(self,
+                 compressionMode=_omit,  # type: Optional[str]
+                 crushRoot=_omit,  # type: Optional[str]
+                 deviceClass=_omit,  # type: Optional[str]
+                 enableRBDStats=_omit,  # type: Optional[bool]
+                 erasureCoded=_omit,  # type: Optional[ErasureCoded]
+                 failureDomain=_omit,  # type: Optional[str]
+                 mirroring=_omit,  # type: Optional[Mirroring]
+                 parameters=_omit,  # type: Optional[Any]
+                 quotas=_omit,  # type: Optional[Quotas]
+                 replicated=_omit,  # type: Optional[Replicated]
+                 statusCheck=_omit,  # type: Optional[StatusCheck]
+                 ):
+        super(DataPoolsItem, self).__init__(
+            compressionMode=compressionMode,
+            crushRoot=crushRoot,
+            deviceClass=deviceClass,
+            enableRBDStats=enableRBDStats,
+            erasureCoded=erasureCoded,
+            failureDomain=failureDomain,
+            mirroring=mirroring,
+            parameters=parameters,
+            quotas=quotas,
+            replicated=replicated,
+            statusCheck=statusCheck,
+        )
+
+    @property
+    def compressionMode(self):
+        # type: () -> Optional[str]
+        return self._property_impl('compressionMode')
+    
+    @compressionMode.setter
+    def compressionMode(self, new_val):
+        # type: (Optional[str]) -> None
+        self._compressionMode = new_val
+    
+    @property
+    def crushRoot(self):
+        # type: () -> Optional[str]
+        return self._property_impl('crushRoot')
+    
+    @crushRoot.setter
+    def crushRoot(self, new_val):
+        # type: (Optional[str]) -> None
+        self._crushRoot = new_val
+    
+    @property
+    def deviceClass(self):
+        # type: () -> Optional[str]
+        return self._property_impl('deviceClass')
+    
+    @deviceClass.setter
+    def deviceClass(self, new_val):
+        # type: (Optional[str]) -> None
+        self._deviceClass = new_val
+    
+    @property
+    def enableRBDStats(self):
+        # type: () -> bool
+        return self._property_impl('enableRBDStats')
+    
+    @enableRBDStats.setter
+    def enableRBDStats(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._enableRBDStats = new_val
+    
+    @property
+    def erasureCoded(self):
+        # type: () -> ErasureCoded
+        return self._property_impl('erasureCoded')
+    
+    @erasureCoded.setter
+    def erasureCoded(self, new_val):
+        # type: (Optional[ErasureCoded]) -> None
+        self._erasureCoded = new_val
+    
+    @property
+    def failureDomain(self):
+        # type: () -> str
+        return self._property_impl('failureDomain')
+    
+    @failureDomain.setter
+    def failureDomain(self, new_val):
+        # type: (Optional[str]) -> None
+        self._failureDomain = new_val
+    
+    @property
+    def mirroring(self):
+        # type: () -> Mirroring
+        return self._property_impl('mirroring')
+    
+    @mirroring.setter
+    def mirroring(self, new_val):
+        # type: (Optional[Mirroring]) -> None
+        self._mirroring = new_val
+    
+    @property
+    def parameters(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('parameters')
+    
+    @parameters.setter
+    def parameters(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._parameters = new_val
+    
+    @property
+    def quotas(self):
+        # type: () -> Optional[Quotas]
+        return self._property_impl('quotas')
+    
+    @quotas.setter
+    def quotas(self, new_val):
+        # type: (Optional[Quotas]) -> None
+        self._quotas = new_val
+    
+    @property
+    def replicated(self):
+        # type: () -> Replicated
+        return self._property_impl('replicated')
+    
+    @replicated.setter
+    def replicated(self, new_val):
+        # type: (Optional[Replicated]) -> None
+        self._replicated = new_val
+    
+    @property
+    def statusCheck(self):
+        # type: () -> StatusCheck
+        return self._property_impl('statusCheck')
+    
+    @statusCheck.setter
+    def statusCheck(self, new_val):
+        # type: (Optional[StatusCheck]) -> None
+        self._statusCheck = new_val
+
+
+class DataPoolsList(CrdObjectList):
+    _items_type = DataPoolsItem
+
+
+class MetadataPool(CrdObject):
+    _properties = [
+        ('compressionMode', 'compressionMode', str, False, True),
+        ('crushRoot', 'crushRoot', str, False, True),
+        ('deviceClass', 'deviceClass', str, False, True),
+        ('enableRBDStats', 'enableRBDStats', bool, False, False),
+        ('erasureCoded', 'erasureCoded', 'ErasureCoded', False, False),
+        ('failureDomain', 'failureDomain', str, False, False),
+        ('mirroring', 'mirroring', 'Mirroring', False, False),
+        ('parameters', 'parameters', object, False, True),
+        ('quotas', 'quotas', 'Quotas', False, True),
+        ('replicated', 'replicated', 'Replicated', False, False),
+        ('statusCheck', 'statusCheck', 'StatusCheck', False, False)
+    ]        
+
+    def __init__(self,
+                 compressionMode=_omit,  # type: Optional[str]
+                 crushRoot=_omit,  # type: Optional[str]
+                 deviceClass=_omit,  # type: Optional[str]
+                 enableRBDStats=_omit,  # type: Optional[bool]
+                 erasureCoded=_omit,  # type: Optional[ErasureCoded]
+                 failureDomain=_omit,  # type: Optional[str]
+                 mirroring=_omit,  # type: Optional[Mirroring]
+                 parameters=_omit,  # type: Optional[Any]
+                 quotas=_omit,  # type: Optional[Quotas]
+                 replicated=_omit,  # type: Optional[Replicated]
+                 statusCheck=_omit,  # type: Optional[StatusCheck]
+                 ):
+        super(MetadataPool, self).__init__(
+            compressionMode=compressionMode,
+            crushRoot=crushRoot,
+            deviceClass=deviceClass,
+            enableRBDStats=enableRBDStats,
+            erasureCoded=erasureCoded,
+            failureDomain=failureDomain,
+            mirroring=mirroring,
+            parameters=parameters,
+            quotas=quotas,
+            replicated=replicated,
+            statusCheck=statusCheck,
+        )
+
+    @property
+    def compressionMode(self):
+        # type: () -> Optional[str]
+        return self._property_impl('compressionMode')
+    
+    @compressionMode.setter
+    def compressionMode(self, new_val):
+        # type: (Optional[str]) -> None
+        self._compressionMode = new_val
+    
+    @property
+    def crushRoot(self):
+        # type: () -> Optional[str]
+        return self._property_impl('crushRoot')
+    
+    @crushRoot.setter
+    def crushRoot(self, new_val):
+        # type: (Optional[str]) -> None
+        self._crushRoot = new_val
+    
+    @property
+    def deviceClass(self):
+        # type: () -> Optional[str]
+        return self._property_impl('deviceClass')
+    
+    @deviceClass.setter
+    def deviceClass(self, new_val):
+        # type: (Optional[str]) -> None
+        self._deviceClass = new_val
+    
+    @property
+    def enableRBDStats(self):
+        # type: () -> bool
+        return self._property_impl('enableRBDStats')
+    
+    @enableRBDStats.setter
+    def enableRBDStats(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._enableRBDStats = new_val
+    
+    @property
+    def erasureCoded(self):
+        # type: () -> ErasureCoded
+        return self._property_impl('erasureCoded')
+    
+    @erasureCoded.setter
+    def erasureCoded(self, new_val):
+        # type: (Optional[ErasureCoded]) -> None
+        self._erasureCoded = new_val
+    
+    @property
+    def failureDomain(self):
+        # type: () -> str
+        return self._property_impl('failureDomain')
+    
+    @failureDomain.setter
+    def failureDomain(self, new_val):
+        # type: (Optional[str]) -> None
+        self._failureDomain = new_val
+    
+    @property
+    def mirroring(self):
+        # type: () -> Mirroring
+        return self._property_impl('mirroring')
+    
+    @mirroring.setter
+    def mirroring(self, new_val):
+        # type: (Optional[Mirroring]) -> None
+        self._mirroring = new_val
+    
+    @property
+    def parameters(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('parameters')
+    
+    @parameters.setter
+    def parameters(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._parameters = new_val
+    
+    @property
+    def quotas(self):
+        # type: () -> Optional[Quotas]
+        return self._property_impl('quotas')
+    
+    @quotas.setter
+    def quotas(self, new_val):
+        # type: (Optional[Quotas]) -> None
+        self._quotas = new_val
+    
+    @property
+    def replicated(self):
+        # type: () -> Replicated
+        return self._property_impl('replicated')
+    
+    @replicated.setter
+    def replicated(self, new_val):
+        # type: (Optional[Replicated]) -> None
+        self._replicated = new_val
+    
+    @property
+    def statusCheck(self):
+        # type: () -> StatusCheck
+        return self._property_impl('statusCheck')
+    
+    @statusCheck.setter
+    def statusCheck(self, new_val):
+        # type: (Optional[StatusCheck]) -> None
+        self._statusCheck = new_val
+
+
+class ValuesList(CrdObjectList):
+    _items_type = str
+
+
+class MatchExpressionsItem(CrdObject):
+    _properties = [
+        ('key', 'key', str, True, False),
+        ('operator', 'operator', str, True, False),
+        ('values', 'values', 'ValuesList', False, False)
+    ]        
+
+    def __init__(self,
+                 key,  # type: str
+                 operator,  # type: str
+                 values=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(MatchExpressionsItem, self).__init__(
+            key=key,
+            operator=operator,
+            values=values,
+        )
+
+    @property
+    def key(self):
+        # type: () -> str
+        return self._property_impl('key')
+    
+    @key.setter
+    def key(self, new_val):
+        # type: (str) -> None
+        self._key = new_val
+    
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._property_impl('operator')
+    
+    @operator.setter
+    def operator(self, new_val):
+        # type: (str) -> None
+        self._operator = new_val
+    
+    @property
+    def values(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('values')
+    
+    @values.setter
+    def values(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._values = new_val
+
+
+class MatchExpressionsList(CrdObjectList):
+    _items_type = MatchExpressionsItem
+
+
+class MatchFieldsItem(CrdObject):
+    _properties = [
+        ('key', 'key', str, True, False),
+        ('operator', 'operator', str, True, False),
+        ('values', 'values', 'ValuesList', False, False)
+    ]        
+
+    def __init__(self,
+                 key,  # type: str
+                 operator,  # type: str
+                 values=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(MatchFieldsItem, self).__init__(
+            key=key,
+            operator=operator,
+            values=values,
+        )
+
+    @property
+    def key(self):
+        # type: () -> str
+        return self._property_impl('key')
+    
+    @key.setter
+    def key(self, new_val):
+        # type: (str) -> None
+        self._key = new_val
+    
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._property_impl('operator')
+    
+    @operator.setter
+    def operator(self, new_val):
+        # type: (str) -> None
+        self._operator = new_val
+    
+    @property
+    def values(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('values')
+    
+    @values.setter
+    def values(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._values = new_val
+
+
+class MatchFieldsList(CrdObjectList):
+    _items_type = MatchFieldsItem
+
+
+class Preference(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchFields', 'matchFields', 'MatchFieldsList', False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchFields=_omit,  # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]]
+                 ):
+        super(Preference, self).__init__(
+            matchExpressions=matchExpressions,
+            matchFields=matchFields,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchFields(self):
+        # type: () -> Union[List[MatchFieldsItem], CrdObjectList]
+        return self._property_impl('matchFields')
+    
+    @matchFields.setter
+    def matchFields(self, new_val):
+        # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None
+        self._matchFields = new_val
+
+
+class PreferredDuringSchedulingIgnoredDuringExecutionItem(CrdObject):
+    _properties = [
+        ('podAffinityTerm', 'podAffinityTerm', 'PodAffinityTerm', False, False),
+        ('weight', 'weight', int, False, False),
+        ('preference', 'preference', 'Preference', False, False)
+    ]        
+
+    def __init__(self,
+                 podAffinityTerm=_omit,  # type: Optional[PodAffinityTerm]
+                 weight=_omit,  # type: Optional[int]
+                 preference=_omit,  # type: Optional[Preference]
+                 ):
+        super(PreferredDuringSchedulingIgnoredDuringExecutionItem, self).__init__(
+            podAffinityTerm=podAffinityTerm,
+            weight=weight,
+            preference=preference,
+        )
+
+    @property
+    def podAffinityTerm(self):
+        # type: () -> PodAffinityTerm
+        return self._property_impl('podAffinityTerm')
+    
+    @podAffinityTerm.setter
+    def podAffinityTerm(self, new_val):
+        # type: (Optional[PodAffinityTerm]) -> None
+        self._podAffinityTerm = new_val
+    
+    @property
+    def weight(self):
+        # type: () -> int
+        return self._property_impl('weight')
+    
+    @weight.setter
+    def weight(self, new_val):
+        # type: (Optional[int]) -> None
+        self._weight = new_val
+    
+    @property
+    def preference(self):
+        # type: () -> Preference
+        return self._property_impl('preference')
+    
+    @preference.setter
+    def preference(self, new_val):
+        # type: (Optional[Preference]) -> None
+        self._preference = new_val
+
+
+class PreferredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList):
+    _items_type = PreferredDuringSchedulingIgnoredDuringExecutionItem
+
+
+class NodeSelectorTermsItem(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchFields', 'matchFields', 'MatchFieldsList', False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchFields=_omit,  # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]]
+                 ):
+        super(NodeSelectorTermsItem, self).__init__(
+            matchExpressions=matchExpressions,
+            matchFields=matchFields,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchFields(self):
+        # type: () -> Union[List[MatchFieldsItem], CrdObjectList]
+        return self._property_impl('matchFields')
+    
+    @matchFields.setter
+    def matchFields(self, new_val):
+        # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None
+        self._matchFields = new_val
+
+
+class NodeSelectorTermsList(CrdObjectList):
+    _items_type = NodeSelectorTermsItem
+
+
+class RequiredDuringSchedulingIgnoredDuringExecution(CrdObject):
+    _properties = [
+        ('nodeSelectorTerms', 'nodeSelectorTerms', 'NodeSelectorTermsList', True, False)
+    ]        
+
+    def __init__(self,
+                 nodeSelectorTerms,  # type: Union[List[NodeSelectorTermsItem], CrdObjectList]
+                 ):
+        super(RequiredDuringSchedulingIgnoredDuringExecution, self).__init__(
+            nodeSelectorTerms=nodeSelectorTerms,
+        )
+
+    @property
+    def nodeSelectorTerms(self):
+        # type: () -> Union[List[NodeSelectorTermsItem], CrdObjectList]
+        return self._property_impl('nodeSelectorTerms')
+    
+    @nodeSelectorTerms.setter
+    def nodeSelectorTerms(self, new_val):
+        # type: (Union[List[NodeSelectorTermsItem], CrdObjectList]) -> None
+        self._nodeSelectorTerms = new_val
+
+
+class NodeAffinity(CrdObject):
+    _properties = [
+        ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False),
+        ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecution', False, False)
+    ]        
+
+    def __init__(self,
+                 preferredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 requiredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[RequiredDuringSchedulingIgnoredDuringExecution]
+                 ):
+        super(NodeAffinity, self).__init__(
+            preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution,
+            requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution,
+        )
+
+    @property
+    def preferredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution')
+    
+    @preferredDuringSchedulingIgnoredDuringExecution.setter
+    def preferredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._preferredDuringSchedulingIgnoredDuringExecution = new_val
+    
+    @property
+    def requiredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> RequiredDuringSchedulingIgnoredDuringExecution
+        return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution')
+    
+    @requiredDuringSchedulingIgnoredDuringExecution.setter
+    def requiredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[RequiredDuringSchedulingIgnoredDuringExecution]) -> None
+        self._requiredDuringSchedulingIgnoredDuringExecution = new_val
+
+
+class LabelSelector(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchLabels', 'matchLabels', object, False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchLabels=_omit,  # type: Optional[Any]
+                 ):
+        super(LabelSelector, self).__init__(
+            matchExpressions=matchExpressions,
+            matchLabels=matchLabels,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchLabels(self):
+        # type: () -> Any
+        return self._property_impl('matchLabels')
+    
+    @matchLabels.setter
+    def matchLabels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._matchLabels = new_val
+
+
+class NamespaceSelector(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchLabels', 'matchLabels', object, False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchLabels=_omit,  # type: Optional[Any]
+                 ):
+        super(NamespaceSelector, self).__init__(
+            matchExpressions=matchExpressions,
+            matchLabels=matchLabels,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchLabels(self):
+        # type: () -> Any
+        return self._property_impl('matchLabels')
+    
+    @matchLabels.setter
+    def matchLabels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._matchLabels = new_val
+
+
+class NamespacesList(CrdObjectList):
+    _items_type = str
+
+
+class PodAffinityTerm(CrdObject):
+    _properties = [
+        ('labelSelector', 'labelSelector', 'LabelSelector', False, False),
+        ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False),
+        ('namespaces', 'namespaces', 'NamespacesList', False, False),
+        ('topologyKey', 'topologyKey', str, True, False)
+    ]        
+
+    def __init__(self,
+                 topologyKey,  # type: str
+                 labelSelector=_omit,  # type: Optional[LabelSelector]
+                 namespaceSelector=_omit,  # type: Optional[NamespaceSelector]
+                 namespaces=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(PodAffinityTerm, self).__init__(
+            topologyKey=topologyKey,
+            labelSelector=labelSelector,
+            namespaceSelector=namespaceSelector,
+            namespaces=namespaces,
+        )
+
+    @property
+    def labelSelector(self):
+        # type: () -> LabelSelector
+        return self._property_impl('labelSelector')
+    
+    @labelSelector.setter
+    def labelSelector(self, new_val):
+        # type: (Optional[LabelSelector]) -> None
+        self._labelSelector = new_val
+    
+    @property
+    def namespaceSelector(self):
+        # type: () -> NamespaceSelector
+        return self._property_impl('namespaceSelector')
+    
+    @namespaceSelector.setter
+    def namespaceSelector(self, new_val):
+        # type: (Optional[NamespaceSelector]) -> None
+        self._namespaceSelector = new_val
+    
+    @property
+    def namespaces(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('namespaces')
+    
+    @namespaces.setter
+    def namespaces(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._namespaces = new_val
+    
+    @property
+    def topologyKey(self):
+        # type: () -> str
+        return self._property_impl('topologyKey')
+    
+    @topologyKey.setter
+    def topologyKey(self, new_val):
+        # type: (str) -> None
+        self._topologyKey = new_val
+
+
+class RequiredDuringSchedulingIgnoredDuringExecutionItem(CrdObject):
+    _properties = [
+        ('labelSelector', 'labelSelector', 'LabelSelector', False, False),
+        ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False),
+        ('namespaces', 'namespaces', 'NamespacesList', False, False),
+        ('topologyKey', 'topologyKey', str, True, False)
+    ]        
+
+    def __init__(self,
+                 topologyKey,  # type: str
+                 labelSelector=_omit,  # type: Optional[LabelSelector]
+                 namespaceSelector=_omit,  # type: Optional[NamespaceSelector]
+                 namespaces=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(RequiredDuringSchedulingIgnoredDuringExecutionItem, self).__init__(
+            topologyKey=topologyKey,
+            labelSelector=labelSelector,
+            namespaceSelector=namespaceSelector,
+            namespaces=namespaces,
+        )
+
+    @property
+    def labelSelector(self):
+        # type: () -> LabelSelector
+        return self._property_impl('labelSelector')
+    
+    @labelSelector.setter
+    def labelSelector(self, new_val):
+        # type: (Optional[LabelSelector]) -> None
+        self._labelSelector = new_val
+    
+    @property
+    def namespaceSelector(self):
+        # type: () -> NamespaceSelector
+        return self._property_impl('namespaceSelector')
+    
+    @namespaceSelector.setter
+    def namespaceSelector(self, new_val):
+        # type: (Optional[NamespaceSelector]) -> None
+        self._namespaceSelector = new_val
+    
+    @property
+    def namespaces(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('namespaces')
+    
+    @namespaces.setter
+    def namespaces(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._namespaces = new_val
+    
+    @property
+    def topologyKey(self):
+        # type: () -> str
+        return self._property_impl('topologyKey')
+    
+    @topologyKey.setter
+    def topologyKey(self, new_val):
+        # type: (str) -> None
+        self._topologyKey = new_val
+
+
+class RequiredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList):
+    _items_type = RequiredDuringSchedulingIgnoredDuringExecutionItem
+
+
+class PodAffinity(CrdObject):
+    _properties = [
+        ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False),
+        ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False)
+    ]        
+
+    def __init__(self,
+                 preferredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 requiredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 ):
+        super(PodAffinity, self).__init__(
+            preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution,
+            requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution,
+        )
+
+    @property
+    def preferredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution')
+    
+    @preferredDuringSchedulingIgnoredDuringExecution.setter
+    def preferredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._preferredDuringSchedulingIgnoredDuringExecution = new_val
+    
+    @property
+    def requiredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution')
+    
+    @requiredDuringSchedulingIgnoredDuringExecution.setter
+    def requiredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._requiredDuringSchedulingIgnoredDuringExecution = new_val
+
+
+class PodAntiAffinity(CrdObject):
+    _properties = [
+        ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False),
+        ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False)
+    ]        
+
+    def __init__(self,
+                 preferredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 requiredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 ):
+        super(PodAntiAffinity, self).__init__(
+            preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution,
+            requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution,
+        )
+
+    @property
+    def preferredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution')
+    
+    @preferredDuringSchedulingIgnoredDuringExecution.setter
+    def preferredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._preferredDuringSchedulingIgnoredDuringExecution = new_val
+    
+    @property
+    def requiredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution')
+    
+    @requiredDuringSchedulingIgnoredDuringExecution.setter
+    def requiredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._requiredDuringSchedulingIgnoredDuringExecution = new_val
+
+
+class TolerationsItem(CrdObject):
+    _properties = [
+        ('effect', 'effect', str, False, False),
+        ('key', 'key', str, False, False),
+        ('operator', 'operator', str, False, False),
+        ('tolerationSeconds', 'tolerationSeconds', int, False, False),
+        ('value', 'value', str, False, False)
+    ]        
+
+    def __init__(self,
+                 effect=_omit,  # type: Optional[str]
+                 key=_omit,  # type: Optional[str]
+                 operator=_omit,  # type: Optional[str]
+                 tolerationSeconds=_omit,  # type: Optional[int]
+                 value=_omit,  # type: Optional[str]
+                 ):
+        super(TolerationsItem, self).__init__(
+            effect=effect,
+            key=key,
+            operator=operator,
+            tolerationSeconds=tolerationSeconds,
+            value=value,
+        )
+
+    @property
+    def effect(self):
+        # type: () -> str
+        return self._property_impl('effect')
+    
+    @effect.setter
+    def effect(self, new_val):
+        # type: (Optional[str]) -> None
+        self._effect = new_val
+    
+    @property
+    def key(self):
+        # type: () -> str
+        return self._property_impl('key')
+    
+    @key.setter
+    def key(self, new_val):
+        # type: (Optional[str]) -> None
+        self._key = new_val
+    
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._property_impl('operator')
+    
+    @operator.setter
+    def operator(self, new_val):
+        # type: (Optional[str]) -> None
+        self._operator = new_val
+    
+    @property
+    def tolerationSeconds(self):
+        # type: () -> int
+        return self._property_impl('tolerationSeconds')
+    
+    @tolerationSeconds.setter
+    def tolerationSeconds(self, new_val):
+        # type: (Optional[int]) -> None
+        self._tolerationSeconds = new_val
+    
+    @property
+    def value(self):
+        # type: () -> str
+        return self._property_impl('value')
+    
+    @value.setter
+    def value(self, new_val):
+        # type: (Optional[str]) -> None
+        self._value = new_val
+
+
+class TolerationsList(CrdObjectList):
+    _items_type = TolerationsItem
+
+
+class TopologySpreadConstraintsItem(CrdObject):
+    _properties = [
+        ('labelSelector', 'labelSelector', 'LabelSelector', False, False),
+        ('maxSkew', 'maxSkew', int, True, False),
+        ('topologyKey', 'topologyKey', str, True, False),
+        ('whenUnsatisfiable', 'whenUnsatisfiable', str, True, False)
+    ]        
+
+    def __init__(self,
+                 maxSkew,  # type: int
+                 topologyKey,  # type: str
+                 whenUnsatisfiable,  # type: str
+                 labelSelector=_omit,  # type: Optional[LabelSelector]
+                 ):
+        super(TopologySpreadConstraintsItem, self).__init__(
+            maxSkew=maxSkew,
+            topologyKey=topologyKey,
+            whenUnsatisfiable=whenUnsatisfiable,
+            labelSelector=labelSelector,
+        )
+
+    @property
+    def labelSelector(self):
+        # type: () -> LabelSelector
+        return self._property_impl('labelSelector')
+    
+    @labelSelector.setter
+    def labelSelector(self, new_val):
+        # type: (Optional[LabelSelector]) -> None
+        self._labelSelector = new_val
+    
+    @property
+    def maxSkew(self):
+        # type: () -> int
+        return self._property_impl('maxSkew')
+    
+    @maxSkew.setter
+    def maxSkew(self, new_val):
+        # type: (int) -> None
+        self._maxSkew = new_val
+    
+    @property
+    def topologyKey(self):
+        # type: () -> str
+        return self._property_impl('topologyKey')
+    
+    @topologyKey.setter
+    def topologyKey(self, new_val):
+        # type: (str) -> None
+        self._topologyKey = new_val
+    
+    @property
+    def whenUnsatisfiable(self):
+        # type: () -> str
+        return self._property_impl('whenUnsatisfiable')
+    
+    @whenUnsatisfiable.setter
+    def whenUnsatisfiable(self, new_val):
+        # type: (str) -> None
+        self._whenUnsatisfiable = new_val
+
+
+class TopologySpreadConstraintsList(CrdObjectList):
+    _items_type = TopologySpreadConstraintsItem
+
+
+class Placement(CrdObject):
+    _properties = [
+        ('nodeAffinity', 'nodeAffinity', 'NodeAffinity', False, False),
+        ('podAffinity', 'podAffinity', 'PodAffinity', False, False),
+        ('podAntiAffinity', 'podAntiAffinity', 'PodAntiAffinity', False, False),
+        ('tolerations', 'tolerations', 'TolerationsList', False, False),
+        ('topologySpreadConstraints', 'topologySpreadConstraints', 'TopologySpreadConstraintsList', False, False)
+    ]        
+
+    def __init__(self,
+                 nodeAffinity=_omit,  # type: Optional[NodeAffinity]
+                 podAffinity=_omit,  # type: Optional[PodAffinity]
+                 podAntiAffinity=_omit,  # type: Optional[PodAntiAffinity]
+                 tolerations=_omit,  # type: Optional[Union[List[TolerationsItem], CrdObjectList]]
+                 topologySpreadConstraints=_omit,  # type: Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]
+                 ):
+        super(Placement, self).__init__(
+            nodeAffinity=nodeAffinity,
+            podAffinity=podAffinity,
+            podAntiAffinity=podAntiAffinity,
+            tolerations=tolerations,
+            topologySpreadConstraints=topologySpreadConstraints,
+        )
+
+    @property
+    def nodeAffinity(self):
+        # type: () -> NodeAffinity
+        return self._property_impl('nodeAffinity')
+    
+    @nodeAffinity.setter
+    def nodeAffinity(self, new_val):
+        # type: (Optional[NodeAffinity]) -> None
+        self._nodeAffinity = new_val
+    
+    @property
+    def podAffinity(self):
+        # type: () -> PodAffinity
+        return self._property_impl('podAffinity')
+    
+    @podAffinity.setter
+    def podAffinity(self, new_val):
+        # type: (Optional[PodAffinity]) -> None
+        self._podAffinity = new_val
+    
+    @property
+    def podAntiAffinity(self):
+        # type: () -> PodAntiAffinity
+        return self._property_impl('podAntiAffinity')
+    
+    @podAntiAffinity.setter
+    def podAntiAffinity(self, new_val):
+        # type: (Optional[PodAntiAffinity]) -> None
+        self._podAntiAffinity = new_val
+    
+    @property
+    def tolerations(self):
+        # type: () -> Union[List[TolerationsItem], CrdObjectList]
+        return self._property_impl('tolerations')
+    
+    @tolerations.setter
+    def tolerations(self, new_val):
+        # type: (Optional[Union[List[TolerationsItem], CrdObjectList]]) -> None
+        self._tolerations = new_val
+    
+    @property
+    def topologySpreadConstraints(self):
+        # type: () -> Union[List[TopologySpreadConstraintsItem], CrdObjectList]
+        return self._property_impl('topologySpreadConstraints')
+    
+    @topologySpreadConstraints.setter
+    def topologySpreadConstraints(self, new_val):
+        # type: (Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]) -> None
+        self._topologySpreadConstraints = new_val
+
+
+class Resources(CrdObject):
+    _properties = [
+        ('limits', 'limits', object, False, False),
+        ('requests', 'requests', object, False, False)
+    ]        
+
+    def __init__(self,
+                 limits=_omit,  # type: Optional[Any]
+                 requests=_omit,  # type: Optional[Any]
+                 ):
+        super(Resources, self).__init__(
+            limits=limits,
+            requests=requests,
+        )
+
+    @property
+    def limits(self):
+        # type: () -> Any
+        return self._property_impl('limits')
+    
+    @limits.setter
+    def limits(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._limits = new_val
+    
+    @property
+    def requests(self):
+        # type: () -> Any
+        return self._property_impl('requests')
+    
+    @requests.setter
+    def requests(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._requests = new_val
+
+
+class MetadataServer(CrdObject):
+    _properties = [
+        ('activeCount', 'activeCount', int, True, False),
+        ('activeStandby', 'activeStandby', bool, False, False),
+        ('annotations', 'annotations', object, False, True),
+        ('labels', 'labels', object, False, True),
+        ('placement', 'placement', 'Placement', False, True),
+        ('priorityClassName', 'priorityClassName', str, False, False),
+        ('resources', 'resources', 'Resources', False, True)
+    ]        
+
+    def __init__(self,
+                 activeCount,  # type: int
+                 activeStandby=_omit,  # type: Optional[bool]
+                 annotations=_omit,  # type: Optional[Any]
+                 labels=_omit,  # type: Optional[Any]
+                 placement=_omit,  # type: Optional[Placement]
+                 priorityClassName=_omit,  # type: Optional[str]
+                 resources=_omit,  # type: Optional[Resources]
+                 ):
+        super(MetadataServer, self).__init__(
+            activeCount=activeCount,
+            activeStandby=activeStandby,
+            annotations=annotations,
+            labels=labels,
+            placement=placement,
+            priorityClassName=priorityClassName,
+            resources=resources,
+        )
+
+    @property
+    def activeCount(self):
+        # type: () -> int
+        return self._property_impl('activeCount')
+    
+    @activeCount.setter
+    def activeCount(self, new_val):
+        # type: (int) -> None
+        self._activeCount = new_val
+    
+    @property
+    def activeStandby(self):
+        # type: () -> bool
+        return self._property_impl('activeStandby')
+    
+    @activeStandby.setter
+    def activeStandby(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._activeStandby = new_val
+    
+    @property
+    def annotations(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('annotations')
+    
+    @annotations.setter
+    def annotations(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._annotations = new_val
+    
+    @property
+    def labels(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('labels')
+    
+    @labels.setter
+    def labels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._labels = new_val
+    
+    @property
+    def placement(self):
+        # type: () -> Optional[Placement]
+        return self._property_impl('placement')
+    
+    @placement.setter
+    def placement(self, new_val):
+        # type: (Optional[Placement]) -> None
+        self._placement = new_val
+    
+    @property
+    def priorityClassName(self):
+        # type: () -> str
+        return self._property_impl('priorityClassName')
+    
+    @priorityClassName.setter
+    def priorityClassName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._priorityClassName = new_val
+    
+    @property
+    def resources(self):
+        # type: () -> Optional[Resources]
+        return self._property_impl('resources')
+    
+    @resources.setter
+    def resources(self, new_val):
+        # type: (Optional[Resources]) -> None
+        self._resources = new_val
+
+
+class Spec(CrdObject):
+    _properties = [
+        ('dataPools', 'dataPools', 'DataPoolsList', True, True),
+        ('metadataPool', 'metadataPool', 'MetadataPool', True, True),
+        ('metadataServer', 'metadataServer', 'MetadataServer', True, False),
+        ('mirroring', 'mirroring', 'Mirroring', False, True),
+        ('preserveFilesystemOnDelete', 'preserveFilesystemOnDelete', bool, False, False),
+        ('preservePoolsOnDelete', 'preservePoolsOnDelete', bool, False, False)
+    ]        
+
+    def __init__(self,
+                 dataPools,  # type: Optional[Union[List[DataPoolsItem], CrdObjectList]]
+                 metadataPool,  # type: Optional[MetadataPool]
+                 metadataServer,  # type: MetadataServer
+                 mirroring=_omit,  # type: Optional[Mirroring]
+                 preserveFilesystemOnDelete=_omit,  # type: Optional[bool]
+                 preservePoolsOnDelete=_omit,  # type: Optional[bool]
+                 ):
+        super(Spec, self).__init__(
+            dataPools=dataPools,
+            metadataPool=metadataPool,
+            metadataServer=metadataServer,
+            mirroring=mirroring,
+            preserveFilesystemOnDelete=preserveFilesystemOnDelete,
+            preservePoolsOnDelete=preservePoolsOnDelete,
+        )
+
+    @property
+    def dataPools(self):
+        # type: () -> Optional[Union[List[DataPoolsItem], CrdObjectList]]
+        return self._property_impl('dataPools')
+    
+    @dataPools.setter
+    def dataPools(self, new_val):
+        # type: (Optional[Union[List[DataPoolsItem], CrdObjectList]]) -> None
+        self._dataPools = new_val
+    
+    @property
+    def metadataPool(self):
+        # type: () -> Optional[MetadataPool]
+        return self._property_impl('metadataPool')
+    
+    @metadataPool.setter
+    def metadataPool(self, new_val):
+        # type: (Optional[MetadataPool]) -> None
+        self._metadataPool = new_val
+    
+    @property
+    def metadataServer(self):
+        # type: () -> MetadataServer
+        return self._property_impl('metadataServer')
+    
+    @metadataServer.setter
+    def metadataServer(self, new_val):
+        # type: (MetadataServer) -> None
+        self._metadataServer = new_val
+    
+    @property
+    def mirroring(self):
+        # type: () -> Optional[Mirroring]
+        return self._property_impl('mirroring')
+    
+    @mirroring.setter
+    def mirroring(self, new_val):
+        # type: (Optional[Mirroring]) -> None
+        self._mirroring = new_val
+    
+    @property
+    def preserveFilesystemOnDelete(self):
+        # type: () -> bool
+        return self._property_impl('preserveFilesystemOnDelete')
+    
+    @preserveFilesystemOnDelete.setter
+    def preserveFilesystemOnDelete(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._preserveFilesystemOnDelete = new_val
+    
+    @property
+    def preservePoolsOnDelete(self):
+        # type: () -> bool
+        return self._property_impl('preservePoolsOnDelete')
+    
+    @preservePoolsOnDelete.setter
+    def preservePoolsOnDelete(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._preservePoolsOnDelete = new_val
+
+
+class Status(CrdObject):
+    _properties = [
+        ('phase', 'phase', str, False, False)
+    ]        
+
+    def __init__(self,
+                 phase=_omit,  # type: Optional[str]
+                 ):
+        super(Status, self).__init__(
+            phase=phase,
+        )
+
+    @property
+    def phase(self):
+        # type: () -> str
+        return self._property_impl('phase')
+    
+    @phase.setter
+    def phase(self, new_val):
+        # type: (Optional[str]) -> None
+        self._phase = new_val
+
+
+class CephFilesystem(CrdClass):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('kind', 'kind', str, False, False),
+        ('metadata', 'metadata', object, False, False),
+        ('spec', 'spec', 'Spec', True, False),
+        ('status', 'status', 'Status', False, False)
+    ]        
+
+    def __init__(self,
+                 spec,  # type: Spec
+                 apiVersion=_omit,  # type: Optional[str]
+                 kind=_omit,  # type: Optional[str]
+                 metadata=_omit,  # type: Optional[Any]
+                 status=_omit,  # type: Optional[Status]
+                 ):
+        super(CephFilesystem, self).__init__(
+            spec=spec,
+            apiVersion=apiVersion,
+            kind=kind,
+            metadata=metadata,
+            status=status,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Any
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._metadata = new_val
+    
+    @property
+    def spec(self):
+        # type: () -> Spec
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Spec) -> None
+        self._spec = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Status
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Status]) -> None
+        self._status = new_val
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephfilesystemmirror.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephfilesystemmirror.py
new file mode 100644
index 000000000..a57fde263
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephfilesystemmirror.py
@@ -0,0 +1,1013 @@
+"""
+This file is automatically generated.
+Do not modify.
+"""
+
+try:
+    from typing import Any, Optional, Union, List
+except ImportError:
+    pass
+
+from .._helper import _omit, CrdObject, CrdObjectList, CrdClass
+
+class ValuesList(CrdObjectList):
+    _items_type = str
+
+
+class MatchExpressionsItem(CrdObject):
+    _properties = [
+        ('key', 'key', str, True, False),
+        ('operator', 'operator', str, True, False),
+        ('values', 'values', 'ValuesList', False, False)
+    ]        
+
+    def __init__(self,
+                 key,  # type: str
+                 operator,  # type: str
+                 values=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(MatchExpressionsItem, self).__init__(
+            key=key,
+            operator=operator,
+            values=values,
+        )
+
+    @property
+    def key(self):
+        # type: () -> str
+        return self._property_impl('key')
+    
+    @key.setter
+    def key(self, new_val):
+        # type: (str) -> None
+        self._key = new_val
+    
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._property_impl('operator')
+    
+    @operator.setter
+    def operator(self, new_val):
+        # type: (str) -> None
+        self._operator = new_val
+    
+    @property
+    def values(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('values')
+    
+    @values.setter
+    def values(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._values = new_val
+
+
+class MatchExpressionsList(CrdObjectList):
+    _items_type = MatchExpressionsItem
+
+
+class MatchFieldsItem(CrdObject):
+    _properties = [
+        ('key', 'key', str, True, False),
+        ('operator', 'operator', str, True, False),
+        ('values', 'values', 'ValuesList', False, False)
+    ]        
+
+    def __init__(self,
+                 key,  # type: str
+                 operator,  # type: str
+                 values=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(MatchFieldsItem, self).__init__(
+            key=key,
+            operator=operator,
+            values=values,
+        )
+
+    @property
+    def key(self):
+        # type: () -> str
+        return self._property_impl('key')
+    
+    @key.setter
+    def key(self, new_val):
+        # type: (str) -> None
+        self._key = new_val
+    
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._property_impl('operator')
+    
+    @operator.setter
+    def operator(self, new_val):
+        # type: (str) -> None
+        self._operator = new_val
+    
+    @property
+    def values(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('values')
+    
+    @values.setter
+    def values(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._values = new_val
+
+
+class MatchFieldsList(CrdObjectList):
+    _items_type = MatchFieldsItem
+
+
+class Preference(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchFields', 'matchFields', 'MatchFieldsList', False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchFields=_omit,  # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]]
+                 ):
+        super(Preference, self).__init__(
+            matchExpressions=matchExpressions,
+            matchFields=matchFields,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchFields(self):
+        # type: () -> Union[List[MatchFieldsItem], CrdObjectList]
+        return self._property_impl('matchFields')
+    
+    @matchFields.setter
+    def matchFields(self, new_val):
+        # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None
+        self._matchFields = new_val
+
+
+class PreferredDuringSchedulingIgnoredDuringExecutionItem(CrdObject):
+    _properties = [
+        ('podAffinityTerm', 'podAffinityTerm', 'PodAffinityTerm', False, False),
+        ('weight', 'weight', int, False, False),
+        ('preference', 'preference', 'Preference', False, False)
+    ]        
+
+    def __init__(self,
+                 podAffinityTerm=_omit,  # type: Optional[PodAffinityTerm]
+                 weight=_omit,  # type: Optional[int]
+                 preference=_omit,  # type: Optional[Preference]
+                 ):
+        super(PreferredDuringSchedulingIgnoredDuringExecutionItem, self).__init__(
+            podAffinityTerm=podAffinityTerm,
+            weight=weight,
+            preference=preference,
+        )
+
+    @property
+    def podAffinityTerm(self):
+        # type: () -> PodAffinityTerm
+        return self._property_impl('podAffinityTerm')
+    
+    @podAffinityTerm.setter
+    def podAffinityTerm(self, new_val):
+        # type: (Optional[PodAffinityTerm]) -> None
+        self._podAffinityTerm = new_val
+    
+    @property
+    def weight(self):
+        # type: () -> int
+        return self._property_impl('weight')
+    
+    @weight.setter
+    def weight(self, new_val):
+        # type: (Optional[int]) -> None
+        self._weight = new_val
+    
+    @property
+    def preference(self):
+        # type: () -> Preference
+        return self._property_impl('preference')
+    
+    @preference.setter
+    def preference(self, new_val):
+        # type: (Optional[Preference]) -> None
+        self._preference = new_val
+
+
+class PreferredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList):
+    _items_type = PreferredDuringSchedulingIgnoredDuringExecutionItem
+
+
+class NodeSelectorTermsItem(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchFields', 'matchFields', 'MatchFieldsList', False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchFields=_omit,  # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]]
+                 ):
+        super(NodeSelectorTermsItem, self).__init__(
+            matchExpressions=matchExpressions,
+            matchFields=matchFields,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchFields(self):
+        # type: () -> Union[List[MatchFieldsItem], CrdObjectList]
+        return self._property_impl('matchFields')
+    
+    @matchFields.setter
+    def matchFields(self, new_val):
+        # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None
+        self._matchFields = new_val
+
+
+class NodeSelectorTermsList(CrdObjectList):
+    _items_type = NodeSelectorTermsItem
+
+
+class RequiredDuringSchedulingIgnoredDuringExecution(CrdObject):
+    _properties = [
+        ('nodeSelectorTerms', 'nodeSelectorTerms', 'NodeSelectorTermsList', True, False)
+    ]        
+
+    def __init__(self,
+                 nodeSelectorTerms,  # type: Union[List[NodeSelectorTermsItem], CrdObjectList]
+                 ):
+        super(RequiredDuringSchedulingIgnoredDuringExecution, self).__init__(
+            nodeSelectorTerms=nodeSelectorTerms,
+        )
+
+    @property
+    def nodeSelectorTerms(self):
+        # type: () -> Union[List[NodeSelectorTermsItem], CrdObjectList]
+        return self._property_impl('nodeSelectorTerms')
+    
+    @nodeSelectorTerms.setter
+    def nodeSelectorTerms(self, new_val):
+        # type: (Union[List[NodeSelectorTermsItem], CrdObjectList]) -> None
+        self._nodeSelectorTerms = new_val
+
+
+class NodeAffinity(CrdObject):
+    _properties = [
+        ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False),
+        ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecution', False, False)
+    ]        
+
+    def __init__(self,
+                 preferredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 requiredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[RequiredDuringSchedulingIgnoredDuringExecution]
+                 ):
+        super(NodeAffinity, self).__init__(
+            preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution,
+            requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution,
+        )
+
+    @property
+    def preferredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution')
+    
+    @preferredDuringSchedulingIgnoredDuringExecution.setter
+    def preferredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._preferredDuringSchedulingIgnoredDuringExecution = new_val
+    
+    @property
+    def requiredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> RequiredDuringSchedulingIgnoredDuringExecution
+        return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution')
+    
+    @requiredDuringSchedulingIgnoredDuringExecution.setter
+    def requiredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[RequiredDuringSchedulingIgnoredDuringExecution]) -> None
+        self._requiredDuringSchedulingIgnoredDuringExecution = new_val
+
+
+class LabelSelector(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchLabels', 'matchLabels', object, False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchLabels=_omit,  # type: Optional[Any]
+                 ):
+        super(LabelSelector, self).__init__(
+            matchExpressions=matchExpressions,
+            matchLabels=matchLabels,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchLabels(self):
+        # type: () -> Any
+        return self._property_impl('matchLabels')
+    
+    @matchLabels.setter
+    def matchLabels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._matchLabels = new_val
+
+
+class NamespaceSelector(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchLabels', 'matchLabels', object, False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchLabels=_omit,  # type: Optional[Any]
+                 ):
+        super(NamespaceSelector, self).__init__(
+            matchExpressions=matchExpressions,
+            matchLabels=matchLabels,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchLabels(self):
+        # type: () -> Any
+        return self._property_impl('matchLabels')
+    
+    @matchLabels.setter
+    def matchLabels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._matchLabels = new_val
+
+
+class NamespacesList(CrdObjectList):
+    _items_type = str
+
+
+class PodAffinityTerm(CrdObject):
+    _properties = [
+        ('labelSelector', 'labelSelector', 'LabelSelector', False, False),
+        ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False),
+        ('namespaces', 'namespaces', 'NamespacesList', False, False),
+        ('topologyKey', 'topologyKey', str, True, False)
+    ]        
+
+    def __init__(self,
+                 topologyKey,  # type: str
+                 labelSelector=_omit,  # type: Optional[LabelSelector]
+                 namespaceSelector=_omit,  # type: Optional[NamespaceSelector]
+                 namespaces=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(PodAffinityTerm, self).__init__(
+            topologyKey=topologyKey,
+            labelSelector=labelSelector,
+            namespaceSelector=namespaceSelector,
+            namespaces=namespaces,
+        )
+
+    @property
+    def labelSelector(self):
+        # type: () -> LabelSelector
+        return self._property_impl('labelSelector')
+    
+    @labelSelector.setter
+    def labelSelector(self, new_val):
+        # type: (Optional[LabelSelector]) -> None
+        self._labelSelector = new_val
+    
+    @property
+    def namespaceSelector(self):
+        # type: () -> NamespaceSelector
+        return self._property_impl('namespaceSelector')
+    
+    @namespaceSelector.setter
+    def namespaceSelector(self, new_val):
+        # type: (Optional[NamespaceSelector]) -> None
+        self._namespaceSelector = new_val
+    
+    @property
+    def namespaces(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('namespaces')
+    
+    @namespaces.setter
+    def namespaces(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._namespaces = new_val
+    
+    @property
+    def topologyKey(self):
+        # type: () -> str
+        return self._property_impl('topologyKey')
+    
+    @topologyKey.setter
+    def topologyKey(self, new_val):
+        # type: (str) -> None
+        self._topologyKey = new_val
+
+
+class RequiredDuringSchedulingIgnoredDuringExecutionItem(CrdObject):
+    _properties = [
+        ('labelSelector', 'labelSelector', 'LabelSelector', False, False),
+        ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False),
+        ('namespaces', 'namespaces', 'NamespacesList', False, False),
+        ('topologyKey', 'topologyKey', str, True, False)
+    ]        
+
+    def __init__(self,
+                 topologyKey,  # type: str
+                 labelSelector=_omit,  # type: Optional[LabelSelector]
+                 namespaceSelector=_omit,  # type: Optional[NamespaceSelector]
+                 namespaces=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(RequiredDuringSchedulingIgnoredDuringExecutionItem, self).__init__(
+            topologyKey=topologyKey,
+            labelSelector=labelSelector,
+            namespaceSelector=namespaceSelector,
+            namespaces=namespaces,
+        )
+
+    @property
+    def labelSelector(self):
+        # type: () -> LabelSelector
+        return self._property_impl('labelSelector')
+    
+    @labelSelector.setter
+    def labelSelector(self, new_val):
+        # type: (Optional[LabelSelector]) -> None
+        self._labelSelector = new_val
+    
+    @property
+    def namespaceSelector(self):
+        # type: () -> NamespaceSelector
+        return self._property_impl('namespaceSelector')
+    
+    @namespaceSelector.setter
+    def namespaceSelector(self, new_val):
+        # type: (Optional[NamespaceSelector]) -> None
+        self._namespaceSelector = new_val
+    
+    @property
+    def namespaces(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('namespaces')
+    
+    @namespaces.setter
+    def namespaces(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._namespaces = new_val
+    
+    @property
+    def topologyKey(self):
+        # type: () -> str
+        return self._property_impl('topologyKey')
+    
+    @topologyKey.setter
+    def topologyKey(self, new_val):
+        # type: (str) -> None
+        self._topologyKey = new_val
+
+
+class RequiredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList):
+    _items_type = RequiredDuringSchedulingIgnoredDuringExecutionItem
+
+
+class PodAffinity(CrdObject):
+    _properties = [
+        ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False),
+        ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False)
+    ]        
+
+    def __init__(self,
+                 preferredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 requiredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 ):
+        super(PodAffinity, self).__init__(
+            preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution,
+            requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution,
+        )
+
+    @property
+    def preferredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution')
+    
+    @preferredDuringSchedulingIgnoredDuringExecution.setter
+    def preferredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._preferredDuringSchedulingIgnoredDuringExecution = new_val
+    
+    @property
+    def requiredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution')
+    
+    @requiredDuringSchedulingIgnoredDuringExecution.setter
+    def requiredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._requiredDuringSchedulingIgnoredDuringExecution = new_val
+
+
+class PodAntiAffinity(CrdObject):
+    _properties = [
+        ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False),
+        ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False)
+    ]        
+
+    def __init__(self,
+                 preferredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 requiredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 ):
+        super(PodAntiAffinity, self).__init__(
+            preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution,
+            requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution,
+        )
+
+    @property
+    def preferredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution')
+    
+    @preferredDuringSchedulingIgnoredDuringExecution.setter
+    def preferredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._preferredDuringSchedulingIgnoredDuringExecution = new_val
+    
+    @property
+    def requiredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution')
+    
+    @requiredDuringSchedulingIgnoredDuringExecution.setter
+    def requiredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._requiredDuringSchedulingIgnoredDuringExecution = new_val
+
+
+class TolerationsItem(CrdObject):
+    _properties = [
+        ('effect', 'effect', str, False, False),
+        ('key', 'key', str, False, False),
+        ('operator', 'operator', str, False, False),
+        ('tolerationSeconds', 'tolerationSeconds', int, False, False),
+        ('value', 'value', str, False, False)
+    ]        
+
+    def __init__(self,
+                 effect=_omit,  # type: Optional[str]
+                 key=_omit,  # type: Optional[str]
+                 operator=_omit,  # type: Optional[str]
+                 tolerationSeconds=_omit,  # type: Optional[int]
+                 value=_omit,  # type: Optional[str]
+                 ):
+        super(TolerationsItem, self).__init__(
+            effect=effect,
+            key=key,
+            operator=operator,
+            tolerationSeconds=tolerationSeconds,
+            value=value,
+        )
+
+    @property
+    def effect(self):
+        # type: () -> str
+        return self._property_impl('effect')
+    
+    @effect.setter
+    def effect(self, new_val):
+        # type: (Optional[str]) -> None
+        self._effect = new_val
+    
+    @property
+    def key(self):
+        # type: () -> str
+        return self._property_impl('key')
+    
+    @key.setter
+    def key(self, new_val):
+        # type: (Optional[str]) -> None
+        self._key = new_val
+    
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._property_impl('operator')
+    
+    @operator.setter
+    def operator(self, new_val):
+        # type: (Optional[str]) -> None
+        self._operator = new_val
+    
+    @property
+    def tolerationSeconds(self):
+        # type: () -> int
+        return self._property_impl('tolerationSeconds')
+    
+    @tolerationSeconds.setter
+    def tolerationSeconds(self, new_val):
+        # type: (Optional[int]) -> None
+        self._tolerationSeconds = new_val
+    
+    @property
+    def value(self):
+        # type: () -> str
+        return self._property_impl('value')
+    
+    @value.setter
+    def value(self, new_val):
+        # type: (Optional[str]) -> None
+        self._value = new_val
+
+
+class TolerationsList(CrdObjectList):
+    _items_type = TolerationsItem
+
+
+class TopologySpreadConstraintsItem(CrdObject):
+    _properties = [
+        ('labelSelector', 'labelSelector', 'LabelSelector', False, False),
+        ('maxSkew', 'maxSkew', int, True, False),
+        ('topologyKey', 'topologyKey', str, True, False),
+        ('whenUnsatisfiable', 'whenUnsatisfiable', str, True, False)
+    ]        
+
+    def __init__(self,
+                 maxSkew,  # type: int
+                 topologyKey,  # type: str
+                 whenUnsatisfiable,  # type: str
+                 labelSelector=_omit,  # type: Optional[LabelSelector]
+                 ):
+        super(TopologySpreadConstraintsItem, self).__init__(
+            maxSkew=maxSkew,
+            topologyKey=topologyKey,
+            whenUnsatisfiable=whenUnsatisfiable,
+            labelSelector=labelSelector,
+        )
+
+    @property
+    def labelSelector(self):
+        # type: () -> LabelSelector
+        return self._property_impl('labelSelector')
+    
+    @labelSelector.setter
+    def labelSelector(self, new_val):
+        # type: (Optional[LabelSelector]) -> None
+        self._labelSelector = new_val
+    
+    @property
+    def maxSkew(self):
+        # type: () -> int
+        return self._property_impl('maxSkew')
+    
+    @maxSkew.setter
+    def maxSkew(self, new_val):
+        # type: (int) -> None
+        self._maxSkew = new_val
+    
+    @property
+    def topologyKey(self):
+        # type: () -> str
+        return self._property_impl('topologyKey')
+    
+    @topologyKey.setter
+    def topologyKey(self, new_val):
+        # type: (str) -> None
+        self._topologyKey = new_val
+    
+    @property
+    def whenUnsatisfiable(self):
+        # type: () -> str
+        return self._property_impl('whenUnsatisfiable')
+    
+    @whenUnsatisfiable.setter
+    def whenUnsatisfiable(self, new_val):
+        # type: (str) -> None
+        self._whenUnsatisfiable = new_val
+
+
+class TopologySpreadConstraintsList(CrdObjectList):
+    _items_type = TopologySpreadConstraintsItem
+
+
+class Placement(CrdObject):
+    _properties = [
+        ('nodeAffinity', 'nodeAffinity', 'NodeAffinity', False, False),
+        ('podAffinity', 'podAffinity', 'PodAffinity', False, False),
+        ('podAntiAffinity', 'podAntiAffinity', 'PodAntiAffinity', False, False),
+        ('tolerations', 'tolerations', 'TolerationsList', False, False),
+        ('topologySpreadConstraints', 'topologySpreadConstraints', 'TopologySpreadConstraintsList', False, False)
+    ]        
+
+    def __init__(self,
+                 nodeAffinity=_omit,  # type: Optional[NodeAffinity]
+                 podAffinity=_omit,  # type: Optional[PodAffinity]
+                 podAntiAffinity=_omit,  # type: Optional[PodAntiAffinity]
+                 tolerations=_omit,  # type: Optional[Union[List[TolerationsItem], CrdObjectList]]
+                 topologySpreadConstraints=_omit,  # type: Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]
+                 ):
+        super(Placement, self).__init__(
+            nodeAffinity=nodeAffinity,
+            podAffinity=podAffinity,
+            podAntiAffinity=podAntiAffinity,
+            tolerations=tolerations,
+            topologySpreadConstraints=topologySpreadConstraints,
+        )
+
+    @property
+    def nodeAffinity(self):
+        # type: () -> NodeAffinity
+        return self._property_impl('nodeAffinity')
+    
+    @nodeAffinity.setter
+    def nodeAffinity(self, new_val):
+        # type: (Optional[NodeAffinity]) -> None
+        self._nodeAffinity = new_val
+    
+    @property
+    def podAffinity(self):
+        # type: () -> PodAffinity
+        return self._property_impl('podAffinity')
+    
+    @podAffinity.setter
+    def podAffinity(self, new_val):
+        # type: (Optional[PodAffinity]) -> None
+        self._podAffinity = new_val
+    
+    @property
+    def podAntiAffinity(self):
+        # type: () -> PodAntiAffinity
+        return self._property_impl('podAntiAffinity')
+    
+    @podAntiAffinity.setter
+    def podAntiAffinity(self, new_val):
+        # type: (Optional[PodAntiAffinity]) -> None
+        self._podAntiAffinity = new_val
+    
+    @property
+    def tolerations(self):
+        # type: () -> Union[List[TolerationsItem], CrdObjectList]
+        return self._property_impl('tolerations')
+    
+    @tolerations.setter
+    def tolerations(self, new_val):
+        # type: (Optional[Union[List[TolerationsItem], CrdObjectList]]) -> None
+        self._tolerations = new_val
+    
+    @property
+    def topologySpreadConstraints(self):
+        # type: () -> Union[List[TopologySpreadConstraintsItem], CrdObjectList]
+        return self._property_impl('topologySpreadConstraints')
+    
+    @topologySpreadConstraints.setter
+    def topologySpreadConstraints(self, new_val):
+        # type: (Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]) -> None
+        self._topologySpreadConstraints = new_val
+
+
+class Resources(CrdObject):
+    _properties = [
+        ('limits', 'limits', object, False, False),
+        ('requests', 'requests', object, False, False)
+    ]        
+
+    def __init__(self,
+                 limits=_omit,  # type: Optional[Any]
+                 requests=_omit,  # type: Optional[Any]
+                 ):
+        super(Resources, self).__init__(
+            limits=limits,
+            requests=requests,
+        )
+
+    @property
+    def limits(self):
+        # type: () -> Any
+        return self._property_impl('limits')
+    
+    @limits.setter
+    def limits(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._limits = new_val
+    
+    @property
+    def requests(self):
+        # type: () -> Any
+        return self._property_impl('requests')
+    
+    @requests.setter
+    def requests(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._requests = new_val
+
+
+class Spec(CrdObject):
+    _properties = [
+        ('annotations', 'annotations', object, False, True),
+        ('labels', 'labels', object, False, True),
+        ('placement', 'placement', 'Placement', False, True),
+        ('priorityClassName', 'priorityClassName', str, False, False),
+        ('resources', 'resources', 'Resources', False, True)
+    ]        
+
+    def __init__(self,
+                 annotations=_omit,  # type: Optional[Any]
+                 labels=_omit,  # type: Optional[Any]
+                 placement=_omit,  # type: Optional[Placement]
+                 priorityClassName=_omit,  # type: Optional[str]
+                 resources=_omit,  # type: Optional[Resources]
+                 ):
+        super(Spec, self).__init__(
+            annotations=annotations,
+            labels=labels,
+            placement=placement,
+            priorityClassName=priorityClassName,
+            resources=resources,
+        )
+
+    @property
+    def annotations(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('annotations')
+    
+    @annotations.setter
+    def annotations(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._annotations = new_val
+    
+    @property
+    def labels(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('labels')
+    
+    @labels.setter
+    def labels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._labels = new_val
+    
+    @property
+    def placement(self):
+        # type: () -> Optional[Placement]
+        return self._property_impl('placement')
+    
+    @placement.setter
+    def placement(self, new_val):
+        # type: (Optional[Placement]) -> None
+        self._placement = new_val
+    
+    @property
+    def priorityClassName(self):
+        # type: () -> str
+        return self._property_impl('priorityClassName')
+    
+    @priorityClassName.setter
+    def priorityClassName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._priorityClassName = new_val
+    
+    @property
+    def resources(self):
+        # type: () -> Optional[Resources]
+        return self._property_impl('resources')
+    
+    @resources.setter
+    def resources(self, new_val):
+        # type: (Optional[Resources]) -> None
+        self._resources = new_val
+
+
+class Status(CrdObject):
+    _properties = [
+        ('phase', 'phase', str, False, False)
+    ]        
+
+    def __init__(self,
+                 phase=_omit,  # type: Optional[str]
+                 ):
+        super(Status, self).__init__(
+            phase=phase,
+        )
+
+    @property
+    def phase(self):
+        # type: () -> str
+        return self._property_impl('phase')
+    
+    @phase.setter
+    def phase(self, new_val):
+        # type: (Optional[str]) -> None
+        self._phase = new_val
+
+
+class CephFilesystemMirror(CrdClass):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('kind', 'kind', str, False, False),
+        ('metadata', 'metadata', object, False, False),
+        ('spec', 'spec', 'Spec', True, False),
+        ('status', 'status', 'Status', False, False)
+    ]        
+
+    def __init__(self,
+                 spec,  # type: Spec
+                 apiVersion=_omit,  # type: Optional[str]
+                 kind=_omit,  # type: Optional[str]
+                 metadata=_omit,  # type: Optional[Any]
+                 status=_omit,  # type: Optional[Status]
+                 ):
+        super(CephFilesystemMirror, self).__init__(
+            spec=spec,
+            apiVersion=apiVersion,
+            kind=kind,
+            metadata=metadata,
+            status=status,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Any
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._metadata = new_val
+    
+    @property
+    def spec(self):
+        # type: () -> Spec
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Spec) -> None
+        self._spec = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Status
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Status]) -> None
+        self._status = new_val
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephnfs.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephnfs.py
new file mode 100644
index 000000000..af069f303
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephnfs.py
@@ -0,0 +1,1111 @@
+"""
+This file is automatically generated.
+Do not modify.
+"""
+
+try:
+    from typing import Any, Optional, Union, List
+except ImportError:
+    pass
+
+from .._helper import _omit, CrdObject, CrdObjectList, CrdClass
+
+class Rados(CrdObject):
+    _properties = [
+        ('namespace', 'namespace', str, True, False),
+        ('pool', 'pool', str, True, False)
+    ]        
+
+    def __init__(self,
+                 namespace,  # type: str
+                 pool,  # type: str
+                 ):
+        super(Rados, self).__init__(
+            namespace=namespace,
+            pool=pool,
+        )
+
+    @property
+    def namespace(self):
+        # type: () -> str
+        return self._property_impl('namespace')
+    
+    @namespace.setter
+    def namespace(self, new_val):
+        # type: (str) -> None
+        self._namespace = new_val
+    
+    @property
+    def pool(self):
+        # type: () -> str
+        return self._property_impl('pool')
+    
+    @pool.setter
+    def pool(self, new_val):
+        # type: (str) -> None
+        self._pool = new_val
+
+
+class ValuesList(CrdObjectList):
+    _items_type = str
+
+
+class MatchExpressionsItem(CrdObject):
+    _properties = [
+        ('key', 'key', str, True, False),
+        ('operator', 'operator', str, True, False),
+        ('values', 'values', 'ValuesList', False, False)
+    ]        
+
+    def __init__(self,
+                 key,  # type: str
+                 operator,  # type: str
+                 values=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(MatchExpressionsItem, self).__init__(
+            key=key,
+            operator=operator,
+            values=values,
+        )
+
+    @property
+    def key(self):
+        # type: () -> str
+        return self._property_impl('key')
+    
+    @key.setter
+    def key(self, new_val):
+        # type: (str) -> None
+        self._key = new_val
+    
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._property_impl('operator')
+    
+    @operator.setter
+    def operator(self, new_val):
+        # type: (str) -> None
+        self._operator = new_val
+    
+    @property
+    def values(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('values')
+    
+    @values.setter
+    def values(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._values = new_val
+
+
+class MatchExpressionsList(CrdObjectList):
+    _items_type = MatchExpressionsItem
+
+
+class MatchFieldsItem(CrdObject):
+    _properties = [
+        ('key', 'key', str, True, False),
+        ('operator', 'operator', str, True, False),
+        ('values', 'values', 'ValuesList', False, False)
+    ]        
+
+    def __init__(self,
+                 key,  # type: str
+                 operator,  # type: str
+                 values=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(MatchFieldsItem, self).__init__(
+            key=key,
+            operator=operator,
+            values=values,
+        )
+
+    @property
+    def key(self):
+        # type: () -> str
+        return self._property_impl('key')
+    
+    @key.setter
+    def key(self, new_val):
+        # type: (str) -> None
+        self._key = new_val
+    
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._property_impl('operator')
+    
+    @operator.setter
+    def operator(self, new_val):
+        # type: (str) -> None
+        self._operator = new_val
+    
+    @property
+    def values(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('values')
+    
+    @values.setter
+    def values(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._values = new_val
+
+
+class MatchFieldsList(CrdObjectList):
+    _items_type = MatchFieldsItem
+
+
+class Preference(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchFields', 'matchFields', 'MatchFieldsList', False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchFields=_omit,  # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]]
+                 ):
+        super(Preference, self).__init__(
+            matchExpressions=matchExpressions,
+            matchFields=matchFields,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchFields(self):
+        # type: () -> Union[List[MatchFieldsItem], CrdObjectList]
+        return self._property_impl('matchFields')
+    
+    @matchFields.setter
+    def matchFields(self, new_val):
+        # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None
+        self._matchFields = new_val
+
+
+class PreferredDuringSchedulingIgnoredDuringExecutionItem(CrdObject):
+    _properties = [
+        ('podAffinityTerm', 'podAffinityTerm', 'PodAffinityTerm', False, False),
+        ('weight', 'weight', int, False, False),
+        ('preference', 'preference', 'Preference', False, False)
+    ]        
+
+    def __init__(self,
+                 podAffinityTerm=_omit,  # type: Optional[PodAffinityTerm]
+                 weight=_omit,  # type: Optional[int]
+                 preference=_omit,  # type: Optional[Preference]
+                 ):
+        super(PreferredDuringSchedulingIgnoredDuringExecutionItem, self).__init__(
+            podAffinityTerm=podAffinityTerm,
+            weight=weight,
+            preference=preference,
+        )
+
+    @property
+    def podAffinityTerm(self):
+        # type: () -> PodAffinityTerm
+        return self._property_impl('podAffinityTerm')
+    
+    @podAffinityTerm.setter
+    def podAffinityTerm(self, new_val):
+        # type: (Optional[PodAffinityTerm]) -> None
+        self._podAffinityTerm = new_val
+    
+    @property
+    def weight(self):
+        # type: () -> int
+        return self._property_impl('weight')
+    
+    @weight.setter
+    def weight(self, new_val):
+        # type: (Optional[int]) -> None
+        self._weight = new_val
+    
+    @property
+    def preference(self):
+        # type: () -> Preference
+        return self._property_impl('preference')
+    
+    @preference.setter
+    def preference(self, new_val):
+        # type: (Optional[Preference]) -> None
+        self._preference = new_val
+
+
+class PreferredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList):
+    _items_type = PreferredDuringSchedulingIgnoredDuringExecutionItem
+
+
+class NodeSelectorTermsItem(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchFields', 'matchFields', 'MatchFieldsList', False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchFields=_omit,  # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]]
+                 ):
+        super(NodeSelectorTermsItem, self).__init__(
+            matchExpressions=matchExpressions,
+            matchFields=matchFields,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchFields(self):
+        # type: () -> Union[List[MatchFieldsItem], CrdObjectList]
+        return self._property_impl('matchFields')
+    
+    @matchFields.setter
+    def matchFields(self, new_val):
+        # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None
+        self._matchFields = new_val
+
+
+class NodeSelectorTermsList(CrdObjectList):
+    _items_type = NodeSelectorTermsItem
+
+
+class RequiredDuringSchedulingIgnoredDuringExecution(CrdObject):
+    _properties = [
+        ('nodeSelectorTerms', 'nodeSelectorTerms', 'NodeSelectorTermsList', True, False)
+    ]        
+
+    def __init__(self,
+                 nodeSelectorTerms,  # type: Union[List[NodeSelectorTermsItem], CrdObjectList]
+                 ):
+        super(RequiredDuringSchedulingIgnoredDuringExecution, self).__init__(
+            nodeSelectorTerms=nodeSelectorTerms,
+        )
+
+    @property
+    def nodeSelectorTerms(self):
+        # type: () -> Union[List[NodeSelectorTermsItem], CrdObjectList]
+        return self._property_impl('nodeSelectorTerms')
+    
+    @nodeSelectorTerms.setter
+    def nodeSelectorTerms(self, new_val):
+        # type: (Union[List[NodeSelectorTermsItem], CrdObjectList]) -> None
+        self._nodeSelectorTerms = new_val
+
+
+class NodeAffinity(CrdObject):
+    _properties = [
+        ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False),
+        ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecution', False, False)
+    ]        
+
+    def __init__(self,
+                 preferredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 requiredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[RequiredDuringSchedulingIgnoredDuringExecution]
+                 ):
+        super(NodeAffinity, self).__init__(
+            preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution,
+            requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution,
+        )
+
+    @property
+    def preferredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution')
+    
+    @preferredDuringSchedulingIgnoredDuringExecution.setter
+    def preferredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._preferredDuringSchedulingIgnoredDuringExecution = new_val
+    
+    @property
+    def requiredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> RequiredDuringSchedulingIgnoredDuringExecution
+        return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution')
+    
+    @requiredDuringSchedulingIgnoredDuringExecution.setter
+    def requiredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[RequiredDuringSchedulingIgnoredDuringExecution]) -> None
+        self._requiredDuringSchedulingIgnoredDuringExecution = new_val
+
+
+class LabelSelector(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchLabels', 'matchLabels', object, False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchLabels=_omit,  # type: Optional[Any]
+                 ):
+        super(LabelSelector, self).__init__(
+            matchExpressions=matchExpressions,
+            matchLabels=matchLabels,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchLabels(self):
+        # type: () -> Any
+        return self._property_impl('matchLabels')
+    
+    @matchLabels.setter
+    def matchLabels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._matchLabels = new_val
+
+
+class NamespaceSelector(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchLabels', 'matchLabels', object, False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchLabels=_omit,  # type: Optional[Any]
+                 ):
+        super(NamespaceSelector, self).__init__(
+            matchExpressions=matchExpressions,
+            matchLabels=matchLabels,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchLabels(self):
+        # type: () -> Any
+        return self._property_impl('matchLabels')
+    
+    @matchLabels.setter
+    def matchLabels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._matchLabels = new_val
+
+
+class NamespacesList(CrdObjectList):
+    _items_type = str
+
+
+class PodAffinityTerm(CrdObject):
+    _properties = [
+        ('labelSelector', 'labelSelector', 'LabelSelector', False, False),
+        ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False),
+        ('namespaces', 'namespaces', 'NamespacesList', False, False),
+        ('topologyKey', 'topologyKey', str, True, False)
+    ]        
+
+    def __init__(self,
+                 topologyKey,  # type: str
+                 labelSelector=_omit,  # type: Optional[LabelSelector]
+                 namespaceSelector=_omit,  # type: Optional[NamespaceSelector]
+                 namespaces=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(PodAffinityTerm, self).__init__(
+            topologyKey=topologyKey,
+            labelSelector=labelSelector,
+            namespaceSelector=namespaceSelector,
+            namespaces=namespaces,
+        )
+
+    @property
+    def labelSelector(self):
+        # type: () -> LabelSelector
+        return self._property_impl('labelSelector')
+    
+    @labelSelector.setter
+    def labelSelector(self, new_val):
+        # type: (Optional[LabelSelector]) -> None
+        self._labelSelector = new_val
+    
+    @property
+    def namespaceSelector(self):
+        # type: () -> NamespaceSelector
+        return self._property_impl('namespaceSelector')
+    
+    @namespaceSelector.setter
+    def namespaceSelector(self, new_val):
+        # type: (Optional[NamespaceSelector]) -> None
+        self._namespaceSelector = new_val
+    
+    @property
+    def namespaces(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('namespaces')
+    
+    @namespaces.setter
+    def namespaces(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._namespaces = new_val
+    
+    @property
+    def topologyKey(self):
+        # type: () -> str
+        return self._property_impl('topologyKey')
+    
+    @topologyKey.setter
+    def topologyKey(self, new_val):
+        # type: (str) -> None
+        self._topologyKey = new_val
+
+
+class RequiredDuringSchedulingIgnoredDuringExecutionItem(CrdObject):
+    _properties = [
+        ('labelSelector', 'labelSelector', 'LabelSelector', False, False),
+        ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False),
+        ('namespaces', 'namespaces', 'NamespacesList', False, False),
+        ('topologyKey', 'topologyKey', str, True, False)
+    ]        
+
+    def __init__(self,
+                 topologyKey,  # type: str
+                 labelSelector=_omit,  # type: Optional[LabelSelector]
+                 namespaceSelector=_omit,  # type: Optional[NamespaceSelector]
+                 namespaces=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(RequiredDuringSchedulingIgnoredDuringExecutionItem, self).__init__(
+            topologyKey=topologyKey,
+            labelSelector=labelSelector,
+            namespaceSelector=namespaceSelector,
+            namespaces=namespaces,
+        )
+
+    @property
+    def labelSelector(self):
+        # type: () -> LabelSelector
+        return self._property_impl('labelSelector')
+    
+    @labelSelector.setter
+    def labelSelector(self, new_val):
+        # type: (Optional[LabelSelector]) -> None
+        self._labelSelector = new_val
+    
+    @property
+    def namespaceSelector(self):
+        # type: () -> NamespaceSelector
+        return self._property_impl('namespaceSelector')
+    
+    @namespaceSelector.setter
+    def namespaceSelector(self, new_val):
+        # type: (Optional[NamespaceSelector]) -> None
+        self._namespaceSelector = new_val
+    
+    @property
+    def namespaces(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('namespaces')
+    
+    @namespaces.setter
+    def namespaces(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._namespaces = new_val
+    
+    @property
+    def topologyKey(self):
+        # type: () -> str
+        return self._property_impl('topologyKey')
+    
+    @topologyKey.setter
+    def topologyKey(self, new_val):
+        # type: (str) -> None
+        self._topologyKey = new_val
+
+
+class RequiredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList):
+    _items_type = RequiredDuringSchedulingIgnoredDuringExecutionItem
+
+
+class PodAffinity(CrdObject):
+    _properties = [
+        ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False),
+        ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False)
+    ]        
+
+    def __init__(self,
+                 preferredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 requiredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 ):
+        super(PodAffinity, self).__init__(
+            preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution,
+            requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution,
+        )
+
+    @property
+    def preferredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution')
+    
+    @preferredDuringSchedulingIgnoredDuringExecution.setter
+    def preferredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._preferredDuringSchedulingIgnoredDuringExecution = new_val
+    
+    @property
+    def requiredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution')
+    
+    @requiredDuringSchedulingIgnoredDuringExecution.setter
+    def requiredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._requiredDuringSchedulingIgnoredDuringExecution = new_val
+
+
+class PodAntiAffinity(CrdObject):
+    _properties = [
+        ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False),
+        ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False)
+    ]        
+
+    def __init__(self,
+                 preferredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 requiredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 ):
+        super(PodAntiAffinity, self).__init__(
+            preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution,
+            requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution,
+        )
+
+    @property
+    def preferredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution')
+    
+    @preferredDuringSchedulingIgnoredDuringExecution.setter
+    def preferredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._preferredDuringSchedulingIgnoredDuringExecution = new_val
+    
+    @property
+    def requiredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution')
+    
+    @requiredDuringSchedulingIgnoredDuringExecution.setter
+    def requiredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._requiredDuringSchedulingIgnoredDuringExecution = new_val
+
+
+class TolerationsItem(CrdObject):
+    _properties = [
+        ('effect', 'effect', str, False, False),
+        ('key', 'key', str, False, False),
+        ('operator', 'operator', str, False, False),
+        ('tolerationSeconds', 'tolerationSeconds', int, False, False),
+        ('value', 'value', str, False, False)
+    ]        
+
+    def __init__(self,
+                 effect=_omit,  # type: Optional[str]
+                 key=_omit,  # type: Optional[str]
+                 operator=_omit,  # type: Optional[str]
+                 tolerationSeconds=_omit,  # type: Optional[int]
+                 value=_omit,  # type: Optional[str]
+                 ):
+        super(TolerationsItem, self).__init__(
+            effect=effect,
+            key=key,
+            operator=operator,
+            tolerationSeconds=tolerationSeconds,
+            value=value,
+        )
+
+    @property
+    def effect(self):
+        # type: () -> str
+        return self._property_impl('effect')
+    
+    @effect.setter
+    def effect(self, new_val):
+        # type: (Optional[str]) -> None
+        self._effect = new_val
+    
+    @property
+    def key(self):
+        # type: () -> str
+        return self._property_impl('key')
+    
+    @key.setter
+    def key(self, new_val):
+        # type: (Optional[str]) -> None
+        self._key = new_val
+    
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._property_impl('operator')
+    
+    @operator.setter
+    def operator(self, new_val):
+        # type: (Optional[str]) -> None
+        self._operator = new_val
+    
+    @property
+    def tolerationSeconds(self):
+        # type: () -> int
+        return self._property_impl('tolerationSeconds')
+    
+    @tolerationSeconds.setter
+    def tolerationSeconds(self, new_val):
+        # type: (Optional[int]) -> None
+        self._tolerationSeconds = new_val
+    
+    @property
+    def value(self):
+        # type: () -> str
+        return self._property_impl('value')
+    
+    @value.setter
+    def value(self, new_val):
+        # type: (Optional[str]) -> None
+        self._value = new_val
+
+
+class TolerationsList(CrdObjectList):
+    _items_type = TolerationsItem
+
+
+class TopologySpreadConstraintsItem(CrdObject):
+    _properties = [
+        ('labelSelector', 'labelSelector', 'LabelSelector', False, False),
+        ('maxSkew', 'maxSkew', int, True, False),
+        ('topologyKey', 'topologyKey', str, True, False),
+        ('whenUnsatisfiable', 'whenUnsatisfiable', str, True, False)
+    ]        
+
+    def __init__(self,
+                 maxSkew,  # type: int
+                 topologyKey,  # type: str
+                 whenUnsatisfiable,  # type: str
+                 labelSelector=_omit,  # type: Optional[LabelSelector]
+                 ):
+        super(TopologySpreadConstraintsItem, self).__init__(
+            maxSkew=maxSkew,
+            topologyKey=topologyKey,
+            whenUnsatisfiable=whenUnsatisfiable,
+            labelSelector=labelSelector,
+        )
+
+    @property
+    def labelSelector(self):
+        # type: () -> LabelSelector
+        return self._property_impl('labelSelector')
+    
+    @labelSelector.setter
+    def labelSelector(self, new_val):
+        # type: (Optional[LabelSelector]) -> None
+        self._labelSelector = new_val
+    
+    @property
+    def maxSkew(self):
+        # type: () -> int
+        return self._property_impl('maxSkew')
+    
+    @maxSkew.setter
+    def maxSkew(self, new_val):
+        # type: (int) -> None
+        self._maxSkew = new_val
+    
+    @property
+    def topologyKey(self):
+        # type: () -> str
+        return self._property_impl('topologyKey')
+    
+    @topologyKey.setter
+    def topologyKey(self, new_val):
+        # type: (str) -> None
+        self._topologyKey = new_val
+    
+    @property
+    def whenUnsatisfiable(self):
+        # type: () -> str
+        return self._property_impl('whenUnsatisfiable')
+    
+    @whenUnsatisfiable.setter
+    def whenUnsatisfiable(self, new_val):
+        # type: (str) -> None
+        self._whenUnsatisfiable = new_val
+
+
+class TopologySpreadConstraintsList(CrdObjectList):
+    _items_type = TopologySpreadConstraintsItem
+
+
+class Placement(CrdObject):
+    _properties = [
+        ('nodeAffinity', 'nodeAffinity', 'NodeAffinity', False, False),
+        ('podAffinity', 'podAffinity', 'PodAffinity', False, False),
+        ('podAntiAffinity', 'podAntiAffinity', 'PodAntiAffinity', False, False),
+        ('tolerations', 'tolerations', 'TolerationsList', False, False),
+        ('topologySpreadConstraints', 'topologySpreadConstraints', 'TopologySpreadConstraintsList', False, False)
+    ]        
+
+    def __init__(self,
+                 nodeAffinity=_omit,  # type: Optional[NodeAffinity]
+                 podAffinity=_omit,  # type: Optional[PodAffinity]
+                 podAntiAffinity=_omit,  # type: Optional[PodAntiAffinity]
+                 tolerations=_omit,  # type: Optional[Union[List[TolerationsItem], CrdObjectList]]
+                 topologySpreadConstraints=_omit,  # type: Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]
+                 ):
+        super(Placement, self).__init__(
+            nodeAffinity=nodeAffinity,
+            podAffinity=podAffinity,
+            podAntiAffinity=podAntiAffinity,
+            tolerations=tolerations,
+            topologySpreadConstraints=topologySpreadConstraints,
+        )
+
+    @property
+    def nodeAffinity(self):
+        # type: () -> NodeAffinity
+        return self._property_impl('nodeAffinity')
+    
+    @nodeAffinity.setter
+    def nodeAffinity(self, new_val):
+        # type: (Optional[NodeAffinity]) -> None
+        self._nodeAffinity = new_val
+    
+    @property
+    def podAffinity(self):
+        # type: () -> PodAffinity
+        return self._property_impl('podAffinity')
+    
+    @podAffinity.setter
+    def podAffinity(self, new_val):
+        # type: (Optional[PodAffinity]) -> None
+        self._podAffinity = new_val
+    
+    @property
+    def podAntiAffinity(self):
+        # type: () -> PodAntiAffinity
+        return self._property_impl('podAntiAffinity')
+    
+    @podAntiAffinity.setter
+    def podAntiAffinity(self, new_val):
+        # type: (Optional[PodAntiAffinity]) -> None
+        self._podAntiAffinity = new_val
+    
+    @property
+    def tolerations(self):
+        # type: () -> Union[List[TolerationsItem], CrdObjectList]
+        return self._property_impl('tolerations')
+    
+    @tolerations.setter
+    def tolerations(self, new_val):
+        # type: (Optional[Union[List[TolerationsItem], CrdObjectList]]) -> None
+        self._tolerations = new_val
+    
+    @property
+    def topologySpreadConstraints(self):
+        # type: () -> Union[List[TopologySpreadConstraintsItem], CrdObjectList]
+        return self._property_impl('topologySpreadConstraints')
+    
+    @topologySpreadConstraints.setter
+    def topologySpreadConstraints(self, new_val):
+        # type: (Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]) -> None
+        self._topologySpreadConstraints = new_val
+
+
+class Resources(CrdObject):
+    _properties = [
+        ('limits', 'limits', object, False, False),
+        ('requests', 'requests', object, False, False)
+    ]        
+
+    def __init__(self,
+                 limits=_omit,  # type: Optional[Any]
+                 requests=_omit,  # type: Optional[Any]
+                 ):
+        super(Resources, self).__init__(
+            limits=limits,
+            requests=requests,
+        )
+
+    @property
+    def limits(self):
+        # type: () -> Any
+        return self._property_impl('limits')
+    
+    @limits.setter
+    def limits(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._limits = new_val
+    
+    @property
+    def requests(self):
+        # type: () -> Any
+        return self._property_impl('requests')
+    
+    @requests.setter
+    def requests(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._requests = new_val
+
+
+class Server(CrdObject):
+    _properties = [
+        ('active', 'active', int, True, False),
+        ('annotations', 'annotations', object, False, True),
+        ('labels', 'labels', object, False, True),
+        ('logLevel', 'logLevel', str, False, False),
+        ('placement', 'placement', 'Placement', False, True),
+        ('priorityClassName', 'priorityClassName', str, False, False),
+        ('resources', 'resources', 'Resources', False, True)
+    ]        
+
+    def __init__(self,
+                 active,  # type: int
+                 annotations=_omit,  # type: Optional[Any]
+                 labels=_omit,  # type: Optional[Any]
+                 logLevel=_omit,  # type: Optional[str]
+                 placement=_omit,  # type: Optional[Placement]
+                 priorityClassName=_omit,  # type: Optional[str]
+                 resources=_omit,  # type: Optional[Resources]
+                 ):
+        super(Server, self).__init__(
+            active=active,
+            annotations=annotations,
+            labels=labels,
+            logLevel=logLevel,
+            placement=placement,
+            priorityClassName=priorityClassName,
+            resources=resources,
+        )
+
+    @property
+    def active(self):
+        # type: () -> int
+        return self._property_impl('active')
+    
+    @active.setter
+    def active(self, new_val):
+        # type: (int) -> None
+        self._active = new_val
+    
+    @property
+    def annotations(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('annotations')
+    
+    @annotations.setter
+    def annotations(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._annotations = new_val
+    
+    @property
+    def labels(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('labels')
+    
+    @labels.setter
+    def labels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._labels = new_val
+    
+    @property
+    def logLevel(self):
+        # type: () -> str
+        return self._property_impl('logLevel')
+    
+    @logLevel.setter
+    def logLevel(self, new_val):
+        # type: (Optional[str]) -> None
+        self._logLevel = new_val
+    
+    @property
+    def placement(self):
+        # type: () -> Optional[Placement]
+        return self._property_impl('placement')
+    
+    @placement.setter
+    def placement(self, new_val):
+        # type: (Optional[Placement]) -> None
+        self._placement = new_val
+    
+    @property
+    def priorityClassName(self):
+        # type: () -> str
+        return self._property_impl('priorityClassName')
+    
+    @priorityClassName.setter
+    def priorityClassName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._priorityClassName = new_val
+    
+    @property
+    def resources(self):
+        # type: () -> Optional[Resources]
+        return self._property_impl('resources')
+    
+    @resources.setter
+    def resources(self, new_val):
+        # type: (Optional[Resources]) -> None
+        self._resources = new_val
+
+
+class Spec(CrdObject):
+    _properties = [
+        ('rados', 'rados', 'Rados', True, False),
+        ('server', 'server', 'Server', True, False)
+    ]        
+
+    def __init__(self,
+                 rados,  # type: Rados
+                 server,  # type: Server
+                 ):
+        super(Spec, self).__init__(
+            rados=rados,
+            server=server,
+        )
+
+    @property
+    def rados(self):
+        # type: () -> Rados
+        return self._property_impl('rados')
+    
+    @rados.setter
+    def rados(self, new_val):
+        # type: (Rados) -> None
+        self._rados = new_val
+    
+    @property
+    def server(self):
+        # type: () -> Server
+        return self._property_impl('server')
+    
+    @server.setter
+    def server(self, new_val):
+        # type: (Server) -> None
+        self._server = new_val
+
+
+class Status(CrdObject):
+    _properties = [
+        ('phase', 'phase', str, False, False)
+    ]        
+
+    def __init__(self,
+                 phase=_omit,  # type: Optional[str]
+                 ):
+        super(Status, self).__init__(
+            phase=phase,
+        )
+
+    @property
+    def phase(self):
+        # type: () -> str
+        return self._property_impl('phase')
+    
+    @phase.setter
+    def phase(self, new_val):
+        # type: (Optional[str]) -> None
+        self._phase = new_val
+
+
+class CephNFS(CrdClass):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('kind', 'kind', str, False, False),
+        ('metadata', 'metadata', object, False, False),
+        ('spec', 'spec', 'Spec', True, False),
+        ('status', 'status', 'Status', False, False)
+    ]        
+
+    def __init__(self,
+                 spec,  # type: Spec
+                 apiVersion=_omit,  # type: Optional[str]
+                 kind=_omit,  # type: Optional[str]
+                 metadata=_omit,  # type: Optional[Any]
+                 status=_omit,  # type: Optional[Status]
+                 ):
+        super(CephNFS, self).__init__(
+            spec=spec,
+            apiVersion=apiVersion,
+            kind=kind,
+            metadata=metadata,
+            status=status,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Any
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._metadata = new_val
+    
+    @property
+    def spec(self):
+        # type: () -> Spec
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Spec) -> None
+        self._spec = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Status
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Status]) -> None
+        self._status = new_val
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectrealm.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectrealm.py
new file mode 100644
index 000000000..eeac3f3f5
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectrealm.py
@@ -0,0 +1,154 @@
+"""
+This file is automatically generated.
+Do not modify.
+"""
+
+try:
+    from typing import Any, Optional, Union, List
+except ImportError:
+    pass
+
+from .._helper import _omit, CrdObject, CrdObjectList, CrdClass
+
+class Pull(CrdObject):
+    _properties = [
+        ('endpoint', 'endpoint', str, True, False)
+    ]        
+
+    def __init__(self,
+                 endpoint,  # type: str
+                 ):
+        super(Pull, self).__init__(
+            endpoint=endpoint,
+        )
+
+    @property
+    def endpoint(self):
+        # type: () -> str
+        return self._property_impl('endpoint')
+    
+    @endpoint.setter
+    def endpoint(self, new_val):
+        # type: (str) -> None
+        self._endpoint = new_val
+
+
+class Spec(CrdObject):
+    _properties = [
+        ('pull', 'pull', 'Pull', True, False)
+    ]        
+
+    def __init__(self,
+                 pull,  # type: Pull
+                 ):
+        super(Spec, self).__init__(
+            pull=pull,
+        )
+
+    @property
+    def pull(self):
+        # type: () -> Pull
+        return self._property_impl('pull')
+    
+    @pull.setter
+    def pull(self, new_val):
+        # type: (Pull) -> None
+        self._pull = new_val
+
+
+class Status(CrdObject):
+    _properties = [
+        ('phase', 'phase', str, False, False)
+    ]        
+
+    def __init__(self,
+                 phase=_omit,  # type: Optional[str]
+                 ):
+        super(Status, self).__init__(
+            phase=phase,
+        )
+
+    @property
+    def phase(self):
+        # type: () -> str
+        return self._property_impl('phase')
+    
+    @phase.setter
+    def phase(self, new_val):
+        # type: (Optional[str]) -> None
+        self._phase = new_val
+
+
+class CephObjectRealm(CrdClass):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('kind', 'kind', str, False, False),
+        ('metadata', 'metadata', object, False, False),
+        ('spec', 'spec', 'Spec', True, True),
+        ('status', 'status', 'Status', False, False)
+    ]        
+
+    def __init__(self,
+                 spec,  # type: Optional[Spec]
+                 apiVersion=_omit,  # type: Optional[str]
+                 kind=_omit,  # type: Optional[str]
+                 metadata=_omit,  # type: Optional[Any]
+                 status=_omit,  # type: Optional[Status]
+                 ):
+        super(CephObjectRealm, self).__init__(
+            spec=spec,
+            apiVersion=apiVersion,
+            kind=kind,
+            metadata=metadata,
+            status=status,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Any
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._metadata = new_val
+    
+    @property
+    def spec(self):
+        # type: () -> Optional[Spec]
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Optional[Spec]) -> None
+        self._spec = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Status
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Status]) -> None
+        self._status = new_val
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectstore.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectstore.py
new file mode 100644
index 000000000..2c7d7cb74
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectstore.py
@@ -0,0 +1,2631 @@
+"""
+This file is automatically generated.
+Do not modify.
+"""
+
+try:
+    from typing import Any, Optional, Union, List
+except ImportError:
+    pass
+
+from .._helper import _omit, CrdObject, CrdObjectList, CrdClass
+
+class ErasureCoded(CrdObject):
+    _properties = [
+        ('algorithm', 'algorithm', str, False, False),
+        ('codingChunks', 'codingChunks', int, True, False),
+        ('dataChunks', 'dataChunks', int, True, False)
+    ]        
+
+    def __init__(self,
+                 codingChunks,  # type: int
+                 dataChunks,  # type: int
+                 algorithm=_omit,  # type: Optional[str]
+                 ):
+        super(ErasureCoded, self).__init__(
+            codingChunks=codingChunks,
+            dataChunks=dataChunks,
+            algorithm=algorithm,
+        )
+
+    @property
+    def algorithm(self):
+        # type: () -> str
+        return self._property_impl('algorithm')
+    
+    @algorithm.setter
+    def algorithm(self, new_val):
+        # type: (Optional[str]) -> None
+        self._algorithm = new_val
+    
+    @property
+    def codingChunks(self):
+        # type: () -> int
+        return self._property_impl('codingChunks')
+    
+    @codingChunks.setter
+    def codingChunks(self, new_val):
+        # type: (int) -> None
+        self._codingChunks = new_val
+    
+    @property
+    def dataChunks(self):
+        # type: () -> int
+        return self._property_impl('dataChunks')
+    
+    @dataChunks.setter
+    def dataChunks(self, new_val):
+        # type: (int) -> None
+        self._dataChunks = new_val
+
+
+class SnapshotSchedulesItem(CrdObject):
+    _properties = [
+        ('interval', 'interval', str, False, False),
+        ('startTime', 'startTime', str, False, False)
+    ]        
+
+    def __init__(self,
+                 interval=_omit,  # type: Optional[str]
+                 startTime=_omit,  # type: Optional[str]
+                 ):
+        super(SnapshotSchedulesItem, self).__init__(
+            interval=interval,
+            startTime=startTime,
+        )
+
+    @property
+    def interval(self):
+        # type: () -> str
+        return self._property_impl('interval')
+    
+    @interval.setter
+    def interval(self, new_val):
+        # type: (Optional[str]) -> None
+        self._interval = new_val
+    
+    @property
+    def startTime(self):
+        # type: () -> str
+        return self._property_impl('startTime')
+    
+    @startTime.setter
+    def startTime(self, new_val):
+        # type: (Optional[str]) -> None
+        self._startTime = new_val
+
+
+class SnapshotSchedulesList(CrdObjectList):
+    _items_type = SnapshotSchedulesItem
+
+
+class Mirroring(CrdObject):
+    _properties = [
+        ('enabled', 'enabled', bool, False, False),
+        ('mode', 'mode', str, False, False),
+        ('snapshotSchedules', 'snapshotSchedules', 'SnapshotSchedulesList', False, False)
+    ]        
+
+    def __init__(self,
+                 enabled=_omit,  # type: Optional[bool]
+                 mode=_omit,  # type: Optional[str]
+                 snapshotSchedules=_omit,  # type: Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]]
+                 ):
+        super(Mirroring, self).__init__(
+            enabled=enabled,
+            mode=mode,
+            snapshotSchedules=snapshotSchedules,
+        )
+
+    @property
+    def enabled(self):
+        # type: () -> bool
+        return self._property_impl('enabled')
+    
+    @enabled.setter
+    def enabled(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._enabled = new_val
+    
+    @property
+    def mode(self):
+        # type: () -> str
+        return self._property_impl('mode')
+    
+    @mode.setter
+    def mode(self, new_val):
+        # type: (Optional[str]) -> None
+        self._mode = new_val
+    
+    @property
+    def snapshotSchedules(self):
+        # type: () -> Union[List[SnapshotSchedulesItem], CrdObjectList]
+        return self._property_impl('snapshotSchedules')
+    
+    @snapshotSchedules.setter
+    def snapshotSchedules(self, new_val):
+        # type: (Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]]) -> None
+        self._snapshotSchedules = new_val
+
+
+class Quotas(CrdObject):
+    _properties = [
+        ('maxBytes', 'maxBytes', int, False, False),
+        ('maxObjects', 'maxObjects', int, False, False),
+        ('maxSize', 'maxSize', str, False, False)
+    ]        
+
+    def __init__(self,
+                 maxBytes=_omit,  # type: Optional[int]
+                 maxObjects=_omit,  # type: Optional[int]
+                 maxSize=_omit,  # type: Optional[str]
+                 ):
+        super(Quotas, self).__init__(
+            maxBytes=maxBytes,
+            maxObjects=maxObjects,
+            maxSize=maxSize,
+        )
+
+    @property
+    def maxBytes(self):
+        # type: () -> int
+        return self._property_impl('maxBytes')
+    
+    @maxBytes.setter
+    def maxBytes(self, new_val):
+        # type: (Optional[int]) -> None
+        self._maxBytes = new_val
+    
+    @property
+    def maxObjects(self):
+        # type: () -> int
+        return self._property_impl('maxObjects')
+    
+    @maxObjects.setter
+    def maxObjects(self, new_val):
+        # type: (Optional[int]) -> None
+        self._maxObjects = new_val
+    
+    @property
+    def maxSize(self):
+        # type: () -> str
+        return self._property_impl('maxSize')
+    
+    @maxSize.setter
+    def maxSize(self, new_val):
+        # type: (Optional[str]) -> None
+        self._maxSize = new_val
+
+
+class Replicated(CrdObject):
+    _properties = [
+        ('replicasPerFailureDomain', 'replicasPerFailureDomain', int, False, False),
+        ('requireSafeReplicaSize', 'requireSafeReplicaSize', bool, False, False),
+        ('size', 'size', int, True, False),
+        ('subFailureDomain', 'subFailureDomain', str, False, False),
+        ('targetSizeRatio', 'targetSizeRatio', float, False, False)
+    ]        
+
+    def __init__(self,
+                 size,  # type: int
+                 replicasPerFailureDomain=_omit,  # type: Optional[int]
+                 requireSafeReplicaSize=_omit,  # type: Optional[bool]
+                 subFailureDomain=_omit,  # type: Optional[str]
+                 targetSizeRatio=_omit,  # type: Optional[float]
+                 ):
+        super(Replicated, self).__init__(
+            size=size,
+            replicasPerFailureDomain=replicasPerFailureDomain,
+            requireSafeReplicaSize=requireSafeReplicaSize,
+            subFailureDomain=subFailureDomain,
+            targetSizeRatio=targetSizeRatio,
+        )
+
+    @property
+    def replicasPerFailureDomain(self):
+        # type: () -> int
+        return self._property_impl('replicasPerFailureDomain')
+    
+    @replicasPerFailureDomain.setter
+    def replicasPerFailureDomain(self, new_val):
+        # type: (Optional[int]) -> None
+        self._replicasPerFailureDomain = new_val
+    
+    @property
+    def requireSafeReplicaSize(self):
+        # type: () -> bool
+        return self._property_impl('requireSafeReplicaSize')
+    
+    @requireSafeReplicaSize.setter
+    def requireSafeReplicaSize(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._requireSafeReplicaSize = new_val
+    
+    @property
+    def size(self):
+        # type: () -> int
+        return self._property_impl('size')
+    
+    @size.setter
+    def size(self, new_val):
+        # type: (int) -> None
+        self._size = new_val
+    
+    @property
+    def subFailureDomain(self):
+        # type: () -> str
+        return self._property_impl('subFailureDomain')
+    
+    @subFailureDomain.setter
+    def subFailureDomain(self, new_val):
+        # type: (Optional[str]) -> None
+        self._subFailureDomain = new_val
+    
+    @property
+    def targetSizeRatio(self):
+        # type: () -> float
+        return self._property_impl('targetSizeRatio')
+    
+    @targetSizeRatio.setter
+    def targetSizeRatio(self, new_val):
+        # type: (Optional[float]) -> None
+        self._targetSizeRatio = new_val
+
+
+class Mirror(CrdObject):
+    _properties = [
+        ('disabled', 'disabled', bool, False, False),
+        ('interval', 'interval', str, False, False),
+        ('timeout', 'timeout', str, False, False)
+    ]        
+
+    def __init__(self,
+                 disabled=_omit,  # type: Optional[bool]
+                 interval=_omit,  # type: Optional[str]
+                 timeout=_omit,  # type: Optional[str]
+                 ):
+        super(Mirror, self).__init__(
+            disabled=disabled,
+            interval=interval,
+            timeout=timeout,
+        )
+
+    @property
+    def disabled(self):
+        # type: () -> bool
+        return self._property_impl('disabled')
+    
+    @disabled.setter
+    def disabled(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._disabled = new_val
+    
+    @property
+    def interval(self):
+        # type: () -> str
+        return self._property_impl('interval')
+    
+    @interval.setter
+    def interval(self, new_val):
+        # type: (Optional[str]) -> None
+        self._interval = new_val
+    
+    @property
+    def timeout(self):
+        # type: () -> str
+        return self._property_impl('timeout')
+    
+    @timeout.setter
+    def timeout(self, new_val):
+        # type: (Optional[str]) -> None
+        self._timeout = new_val
+
+
+class StatusCheck(CrdObject):
+    _properties = [
+        ('mirror', 'mirror', 'Mirror', False, True)
+    ]        
+
+    def __init__(self,
+                 mirror=_omit,  # type: Optional[Mirror]
+                 ):
+        super(StatusCheck, self).__init__(
+            mirror=mirror,
+        )
+
+    @property
+    def mirror(self):
+        # type: () -> Optional[Mirror]
+        return self._property_impl('mirror')
+    
+    @mirror.setter
+    def mirror(self, new_val):
+        # type: (Optional[Mirror]) -> None
+        self._mirror = new_val
+
+
+class DataPool(CrdObject):
+    _properties = [
+        ('compressionMode', 'compressionMode', str, False, True),
+        ('crushRoot', 'crushRoot', str, False, True),
+        ('deviceClass', 'deviceClass', str, False, True),
+        ('enableRBDStats', 'enableRBDStats', bool, False, False),
+        ('erasureCoded', 'erasureCoded', 'ErasureCoded', False, False),
+        ('failureDomain', 'failureDomain', str, False, False),
+        ('mirroring', 'mirroring', 'Mirroring', False, False),
+        ('parameters', 'parameters', object, False, True),
+        ('quotas', 'quotas', 'Quotas', False, True),
+        ('replicated', 'replicated', 'Replicated', False, False),
+        ('statusCheck', 'statusCheck', 'StatusCheck', False, False)
+    ]        
+
+    def __init__(self,
+                 compressionMode=_omit,  # type: Optional[str]
+                 crushRoot=_omit,  # type: Optional[str]
+                 deviceClass=_omit,  # type: Optional[str]
+                 enableRBDStats=_omit,  # type: Optional[bool]
+                 erasureCoded=_omit,  # type: Optional[ErasureCoded]
+                 failureDomain=_omit,  # type: Optional[str]
+                 mirroring=_omit,  # type: Optional[Mirroring]
+                 parameters=_omit,  # type: Optional[Any]
+                 quotas=_omit,  # type: Optional[Quotas]
+                 replicated=_omit,  # type: Optional[Replicated]
+                 statusCheck=_omit,  # type: Optional[StatusCheck]
+                 ):
+        super(DataPool, self).__init__(
+            compressionMode=compressionMode,
+            crushRoot=crushRoot,
+            deviceClass=deviceClass,
+            enableRBDStats=enableRBDStats,
+            erasureCoded=erasureCoded,
+            failureDomain=failureDomain,
+            mirroring=mirroring,
+            parameters=parameters,
+            quotas=quotas,
+            replicated=replicated,
+            statusCheck=statusCheck,
+        )
+
+    @property
+    def compressionMode(self):
+        # type: () -> Optional[str]
+        return self._property_impl('compressionMode')
+    
+    @compressionMode.setter
+    def compressionMode(self, new_val):
+        # type: (Optional[str]) -> None
+        self._compressionMode = new_val
+    
+    @property
+    def crushRoot(self):
+        # type: () -> Optional[str]
+        return self._property_impl('crushRoot')
+    
+    @crushRoot.setter
+    def crushRoot(self, new_val):
+        # type: (Optional[str]) -> None
+        self._crushRoot = new_val
+    
+    @property
+    def deviceClass(self):
+        # type: () -> Optional[str]
+        return self._property_impl('deviceClass')
+    
+    @deviceClass.setter
+    def deviceClass(self, new_val):
+        # type: (Optional[str]) -> None
+        self._deviceClass = new_val
+    
+    @property
+    def enableRBDStats(self):
+        # type: () -> bool
+        return self._property_impl('enableRBDStats')
+    
+    @enableRBDStats.setter
+    def enableRBDStats(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._enableRBDStats = new_val
+    
+    @property
+    def erasureCoded(self):
+        # type: () -> ErasureCoded
+        return self._property_impl('erasureCoded')
+    
+    @erasureCoded.setter
+    def erasureCoded(self, new_val):
+        # type: (Optional[ErasureCoded]) -> None
+        self._erasureCoded = new_val
+    
+    @property
+    def failureDomain(self):
+        # type: () -> str
+        return self._property_impl('failureDomain')
+    
+    @failureDomain.setter
+    def failureDomain(self, new_val):
+        # type: (Optional[str]) -> None
+        self._failureDomain = new_val
+    
+    @property
+    def mirroring(self):
+        # type: () -> Mirroring
+        return self._property_impl('mirroring')
+    
+    @mirroring.setter
+    def mirroring(self, new_val):
+        # type: (Optional[Mirroring]) -> None
+        self._mirroring = new_val
+    
+    @property
+    def parameters(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('parameters')
+    
+    @parameters.setter
+    def parameters(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._parameters = new_val
+    
+    @property
+    def quotas(self):
+        # type: () -> Optional[Quotas]
+        return self._property_impl('quotas')
+    
+    @quotas.setter
+    def quotas(self, new_val):
+        # type: (Optional[Quotas]) -> None
+        self._quotas = new_val
+    
+    @property
+    def replicated(self):
+        # type: () -> Replicated
+        return self._property_impl('replicated')
+    
+    @replicated.setter
+    def replicated(self, new_val):
+        # type: (Optional[Replicated]) -> None
+        self._replicated = new_val
+    
+    @property
+    def statusCheck(self):
+        # type: () -> StatusCheck
+        return self._property_impl('statusCheck')
+    
+    @statusCheck.setter
+    def statusCheck(self, new_val):
+        # type: (Optional[StatusCheck]) -> None
+        self._statusCheck = new_val
+
+
+class TargetRef(CrdObject):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('fieldPath', 'fieldPath', str, False, False),
+        ('kind', 'kind', str, False, False),
+        ('name', 'name', str, False, False),
+        ('namespace', 'namespace', str, False, False),
+        ('resourceVersion', 'resourceVersion', str, False, False),
+        ('uid', 'uid', str, False, False)
+    ]        
+
+    def __init__(self,
+                 apiVersion=_omit,  # type: Optional[str]
+                 fieldPath=_omit,  # type: Optional[str]
+                 kind=_omit,  # type: Optional[str]
+                 name=_omit,  # type: Optional[str]
+                 namespace=_omit,  # type: Optional[str]
+                 resourceVersion=_omit,  # type: Optional[str]
+                 uid=_omit,  # type: Optional[str]
+                 ):
+        super(TargetRef, self).__init__(
+            apiVersion=apiVersion,
+            fieldPath=fieldPath,
+            kind=kind,
+            name=name,
+            namespace=namespace,
+            resourceVersion=resourceVersion,
+            uid=uid,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def fieldPath(self):
+        # type: () -> str
+        return self._property_impl('fieldPath')
+    
+    @fieldPath.setter
+    def fieldPath(self, new_val):
+        # type: (Optional[str]) -> None
+        self._fieldPath = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def name(self):
+        # type: () -> str
+        return self._property_impl('name')
+    
+    @name.setter
+    def name(self, new_val):
+        # type: (Optional[str]) -> None
+        self._name = new_val
+    
+    @property
+    def namespace(self):
+        # type: () -> str
+        return self._property_impl('namespace')
+    
+    @namespace.setter
+    def namespace(self, new_val):
+        # type: (Optional[str]) -> None
+        self._namespace = new_val
+    
+    @property
+    def resourceVersion(self):
+        # type: () -> str
+        return self._property_impl('resourceVersion')
+    
+    @resourceVersion.setter
+    def resourceVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._resourceVersion = new_val
+    
+    @property
+    def uid(self):
+        # type: () -> str
+        return self._property_impl('uid')
+    
+    @uid.setter
+    def uid(self, new_val):
+        # type: (Optional[str]) -> None
+        self._uid = new_val
+
+
+class ExternalRgwEndpointsItem(CrdObject):
+    _properties = [
+        ('hostname', 'hostname', str, False, False),
+        ('ip', 'ip', str, True, False),
+        ('nodeName', 'nodeName', str, False, False),
+        ('targetRef', 'targetRef', 'TargetRef', False, False)
+    ]        
+
+    def __init__(self,
+                 ip,  # type: str
+                 hostname=_omit,  # type: Optional[str]
+                 nodeName=_omit,  # type: Optional[str]
+                 targetRef=_omit,  # type: Optional[TargetRef]
+                 ):
+        super(ExternalRgwEndpointsItem, self).__init__(
+            ip=ip,
+            hostname=hostname,
+            nodeName=nodeName,
+            targetRef=targetRef,
+        )
+
+    @property
+    def hostname(self):
+        # type: () -> str
+        return self._property_impl('hostname')
+    
+    @hostname.setter
+    def hostname(self, new_val):
+        # type: (Optional[str]) -> None
+        self._hostname = new_val
+    
+    @property
+    def ip(self):
+        # type: () -> str
+        return self._property_impl('ip')
+    
+    @ip.setter
+    def ip(self, new_val):
+        # type: (str) -> None
+        self._ip = new_val
+    
+    @property
+    def nodeName(self):
+        # type: () -> str
+        return self._property_impl('nodeName')
+    
+    @nodeName.setter
+    def nodeName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._nodeName = new_val
+    
+    @property
+    def targetRef(self):
+        # type: () -> TargetRef
+        return self._property_impl('targetRef')
+    
+    @targetRef.setter
+    def targetRef(self, new_val):
+        # type: (Optional[TargetRef]) -> None
+        self._targetRef = new_val
+
+
+class ExternalRgwEndpointsList(CrdObjectList):
+    _items_type = ExternalRgwEndpointsItem
+
+
+class ValuesList(CrdObjectList):
+    _items_type = str
+
+
+class MatchExpressionsItem(CrdObject):
+    _properties = [
+        ('key', 'key', str, True, False),
+        ('operator', 'operator', str, True, False),
+        ('values', 'values', 'ValuesList', False, False)
+    ]        
+
+    def __init__(self,
+                 key,  # type: str
+                 operator,  # type: str
+                 values=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(MatchExpressionsItem, self).__init__(
+            key=key,
+            operator=operator,
+            values=values,
+        )
+
+    @property
+    def key(self):
+        # type: () -> str
+        return self._property_impl('key')
+    
+    @key.setter
+    def key(self, new_val):
+        # type: (str) -> None
+        self._key = new_val
+    
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._property_impl('operator')
+    
+    @operator.setter
+    def operator(self, new_val):
+        # type: (str) -> None
+        self._operator = new_val
+    
+    @property
+    def values(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('values')
+    
+    @values.setter
+    def values(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._values = new_val
+
+
+class MatchExpressionsList(CrdObjectList):
+    _items_type = MatchExpressionsItem
+
+
+class MatchFieldsItem(CrdObject):
+    _properties = [
+        ('key', 'key', str, True, False),
+        ('operator', 'operator', str, True, False),
+        ('values', 'values', 'ValuesList', False, False)
+    ]        
+
+    def __init__(self,
+                 key,  # type: str
+                 operator,  # type: str
+                 values=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(MatchFieldsItem, self).__init__(
+            key=key,
+            operator=operator,
+            values=values,
+        )
+
+    @property
+    def key(self):
+        # type: () -> str
+        return self._property_impl('key')
+    
+    @key.setter
+    def key(self, new_val):
+        # type: (str) -> None
+        self._key = new_val
+    
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._property_impl('operator')
+    
+    @operator.setter
+    def operator(self, new_val):
+        # type: (str) -> None
+        self._operator = new_val
+    
+    @property
+    def values(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('values')
+    
+    @values.setter
+    def values(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._values = new_val
+
+
+class MatchFieldsList(CrdObjectList):
+    _items_type = MatchFieldsItem
+
+
+class Preference(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchFields', 'matchFields', 'MatchFieldsList', False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchFields=_omit,  # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]]
+                 ):
+        super(Preference, self).__init__(
+            matchExpressions=matchExpressions,
+            matchFields=matchFields,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchFields(self):
+        # type: () -> Union[List[MatchFieldsItem], CrdObjectList]
+        return self._property_impl('matchFields')
+    
+    @matchFields.setter
+    def matchFields(self, new_val):
+        # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None
+        self._matchFields = new_val
+
+
+class PreferredDuringSchedulingIgnoredDuringExecutionItem(CrdObject):
+    _properties = [
+        ('podAffinityTerm', 'podAffinityTerm', 'PodAffinityTerm', False, False),
+        ('weight', 'weight', int, False, False),
+        ('preference', 'preference', 'Preference', False, False)
+    ]        
+
+    def __init__(self,
+                 podAffinityTerm=_omit,  # type: Optional[PodAffinityTerm]
+                 weight=_omit,  # type: Optional[int]
+                 preference=_omit,  # type: Optional[Preference]
+                 ):
+        super(PreferredDuringSchedulingIgnoredDuringExecutionItem, self).__init__(
+            podAffinityTerm=podAffinityTerm,
+            weight=weight,
+            preference=preference,
+        )
+
+    @property
+    def podAffinityTerm(self):
+        # type: () -> PodAffinityTerm
+        return self._property_impl('podAffinityTerm')
+    
+    @podAffinityTerm.setter
+    def podAffinityTerm(self, new_val):
+        # type: (Optional[PodAffinityTerm]) -> None
+        self._podAffinityTerm = new_val
+    
+    @property
+    def weight(self):
+        # type: () -> int
+        return self._property_impl('weight')
+    
+    @weight.setter
+    def weight(self, new_val):
+        # type: (Optional[int]) -> None
+        self._weight = new_val
+    
+    @property
+    def preference(self):
+        # type: () -> Preference
+        return self._property_impl('preference')
+    
+    @preference.setter
+    def preference(self, new_val):
+        # type: (Optional[Preference]) -> None
+        self._preference = new_val
+
+
+class PreferredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList):
+    _items_type = PreferredDuringSchedulingIgnoredDuringExecutionItem
+
+
+class NodeSelectorTermsItem(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchFields', 'matchFields', 'MatchFieldsList', False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchFields=_omit,  # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]]
+                 ):
+        super(NodeSelectorTermsItem, self).__init__(
+            matchExpressions=matchExpressions,
+            matchFields=matchFields,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchFields(self):
+        # type: () -> Union[List[MatchFieldsItem], CrdObjectList]
+        return self._property_impl('matchFields')
+    
+    @matchFields.setter
+    def matchFields(self, new_val):
+        # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None
+        self._matchFields = new_val
+
+
+class NodeSelectorTermsList(CrdObjectList):
+    _items_type = NodeSelectorTermsItem
+
+
+class RequiredDuringSchedulingIgnoredDuringExecution(CrdObject):
+    _properties = [
+        ('nodeSelectorTerms', 'nodeSelectorTerms', 'NodeSelectorTermsList', True, False)
+    ]        
+
+    def __init__(self,
+                 nodeSelectorTerms,  # type: Union[List[NodeSelectorTermsItem], CrdObjectList]
+                 ):
+        super(RequiredDuringSchedulingIgnoredDuringExecution, self).__init__(
+            nodeSelectorTerms=nodeSelectorTerms,
+        )
+
+    @property
+    def nodeSelectorTerms(self):
+        # type: () -> Union[List[NodeSelectorTermsItem], CrdObjectList]
+        return self._property_impl('nodeSelectorTerms')
+    
+    @nodeSelectorTerms.setter
+    def nodeSelectorTerms(self, new_val):
+        # type: (Union[List[NodeSelectorTermsItem], CrdObjectList]) -> None
+        self._nodeSelectorTerms = new_val
+
+
+class NodeAffinity(CrdObject):
+    _properties = [
+        ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False),
+        ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecution', False, False)
+    ]        
+
+    def __init__(self,
+                 preferredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 requiredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[RequiredDuringSchedulingIgnoredDuringExecution]
+                 ):
+        super(NodeAffinity, self).__init__(
+            preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution,
+            requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution,
+        )
+
+    @property
+    def preferredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution')
+    
+    @preferredDuringSchedulingIgnoredDuringExecution.setter
+    def preferredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._preferredDuringSchedulingIgnoredDuringExecution = new_val
+    
+    @property
+    def requiredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> RequiredDuringSchedulingIgnoredDuringExecution
+        return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution')
+    
+    @requiredDuringSchedulingIgnoredDuringExecution.setter
+    def requiredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[RequiredDuringSchedulingIgnoredDuringExecution]) -> None
+        self._requiredDuringSchedulingIgnoredDuringExecution = new_val
+
+
+class LabelSelector(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchLabels', 'matchLabels', object, False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchLabels=_omit,  # type: Optional[Any]
+                 ):
+        super(LabelSelector, self).__init__(
+            matchExpressions=matchExpressions,
+            matchLabels=matchLabels,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchLabels(self):
+        # type: () -> Any
+        return self._property_impl('matchLabels')
+    
+    @matchLabels.setter
+    def matchLabels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._matchLabels = new_val
+
+
+class NamespaceSelector(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchLabels', 'matchLabels', object, False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchLabels=_omit,  # type: Optional[Any]
+                 ):
+        super(NamespaceSelector, self).__init__(
+            matchExpressions=matchExpressions,
+            matchLabels=matchLabels,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchLabels(self):
+        # type: () -> Any
+        return self._property_impl('matchLabels')
+    
+    @matchLabels.setter
+    def matchLabels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._matchLabels = new_val
+
+
+class NamespacesList(CrdObjectList):
+    _items_type = str
+
+
+class PodAffinityTerm(CrdObject):
+    _properties = [
+        ('labelSelector', 'labelSelector', 'LabelSelector', False, False),
+        ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False),
+        ('namespaces', 'namespaces', 'NamespacesList', False, False),
+        ('topologyKey', 'topologyKey', str, True, False)
+    ]        
+
+    def __init__(self,
+                 topologyKey,  # type: str
+                 labelSelector=_omit,  # type: Optional[LabelSelector]
+                 namespaceSelector=_omit,  # type: Optional[NamespaceSelector]
+                 namespaces=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(PodAffinityTerm, self).__init__(
+            topologyKey=topologyKey,
+            labelSelector=labelSelector,
+            namespaceSelector=namespaceSelector,
+            namespaces=namespaces,
+        )
+
+    @property
+    def labelSelector(self):
+        # type: () -> LabelSelector
+        return self._property_impl('labelSelector')
+    
+    @labelSelector.setter
+    def labelSelector(self, new_val):
+        # type: (Optional[LabelSelector]) -> None
+        self._labelSelector = new_val
+    
+    @property
+    def namespaceSelector(self):
+        # type: () -> NamespaceSelector
+        return self._property_impl('namespaceSelector')
+    
+    @namespaceSelector.setter
+    def namespaceSelector(self, new_val):
+        # type: (Optional[NamespaceSelector]) -> None
+        self._namespaceSelector = new_val
+    
+    @property
+    def namespaces(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('namespaces')
+    
+    @namespaces.setter
+    def namespaces(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._namespaces = new_val
+    
+    @property
+    def topologyKey(self):
+        # type: () -> str
+        return self._property_impl('topologyKey')
+    
+    @topologyKey.setter
+    def topologyKey(self, new_val):
+        # type: (str) -> None
+        self._topologyKey = new_val
+
+
+class RequiredDuringSchedulingIgnoredDuringExecutionItem(CrdObject):
+    _properties = [
+        ('labelSelector', 'labelSelector', 'LabelSelector', False, False),
+        ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False),
+        ('namespaces', 'namespaces', 'NamespacesList', False, False),
+        ('topologyKey', 'topologyKey', str, True, False)
+    ]        
+
+    def __init__(self,
+                 topologyKey,  # type: str
+                 labelSelector=_omit,  # type: Optional[LabelSelector]
+                 namespaceSelector=_omit,  # type: Optional[NamespaceSelector]
+                 namespaces=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(RequiredDuringSchedulingIgnoredDuringExecutionItem, self).__init__(
+            topologyKey=topologyKey,
+            labelSelector=labelSelector,
+            namespaceSelector=namespaceSelector,
+            namespaces=namespaces,
+        )
+
+    @property
+    def labelSelector(self):
+        # type: () -> LabelSelector
+        return self._property_impl('labelSelector')
+    
+    @labelSelector.setter
+    def labelSelector(self, new_val):
+        # type: (Optional[LabelSelector]) -> None
+        self._labelSelector = new_val
+    
+    @property
+    def namespaceSelector(self):
+        # type: () -> NamespaceSelector
+        return self._property_impl('namespaceSelector')
+    
+    @namespaceSelector.setter
+    def namespaceSelector(self, new_val):
+        # type: (Optional[NamespaceSelector]) -> None
+        self._namespaceSelector = new_val
+    
+    @property
+    def namespaces(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('namespaces')
+    
+    @namespaces.setter
+    def namespaces(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._namespaces = new_val
+    
+    @property
+    def topologyKey(self):
+        # type: () -> str
+        return self._property_impl('topologyKey')
+    
+    @topologyKey.setter
+    def topologyKey(self, new_val):
+        # type: (str) -> None
+        self._topologyKey = new_val
+
+
+class RequiredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList):
+    _items_type = RequiredDuringSchedulingIgnoredDuringExecutionItem
+
+
+class PodAffinity(CrdObject):
+    _properties = [
+        ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False),
+        ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False)
+    ]        
+
+    def __init__(self,
+                 preferredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 requiredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 ):
+        super(PodAffinity, self).__init__(
+            preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution,
+            requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution,
+        )
+
+    @property
+    def preferredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution')
+    
+    @preferredDuringSchedulingIgnoredDuringExecution.setter
+    def preferredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._preferredDuringSchedulingIgnoredDuringExecution = new_val
+    
+    @property
+    def requiredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution')
+    
+    @requiredDuringSchedulingIgnoredDuringExecution.setter
+    def requiredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._requiredDuringSchedulingIgnoredDuringExecution = new_val
+
+
+class PodAntiAffinity(CrdObject):
+    _properties = [
+        ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False),
+        ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False)
+    ]        
+
+    def __init__(self,
+                 preferredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 requiredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 ):
+        super(PodAntiAffinity, self).__init__(
+            preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution,
+            requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution,
+        )
+
+    @property
+    def preferredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution')
+    
+    @preferredDuringSchedulingIgnoredDuringExecution.setter
+    def preferredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._preferredDuringSchedulingIgnoredDuringExecution = new_val
+    
+    @property
+    def requiredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution')
+    
+    @requiredDuringSchedulingIgnoredDuringExecution.setter
+    def requiredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._requiredDuringSchedulingIgnoredDuringExecution = new_val
+
+
+class TolerationsItem(CrdObject):
+    _properties = [
+        ('effect', 'effect', str, False, False),
+        ('key', 'key', str, False, False),
+        ('operator', 'operator', str, False, False),
+        ('tolerationSeconds', 'tolerationSeconds', int, False, False),
+        ('value', 'value', str, False, False)
+    ]        
+
+    def __init__(self,
+                 effect=_omit,  # type: Optional[str]
+                 key=_omit,  # type: Optional[str]
+                 operator=_omit,  # type: Optional[str]
+                 tolerationSeconds=_omit,  # type: Optional[int]
+                 value=_omit,  # type: Optional[str]
+                 ):
+        super(TolerationsItem, self).__init__(
+            effect=effect,
+            key=key,
+            operator=operator,
+            tolerationSeconds=tolerationSeconds,
+            value=value,
+        )
+
+    @property
+    def effect(self):
+        # type: () -> str
+        return self._property_impl('effect')
+    
+    @effect.setter
+    def effect(self, new_val):
+        # type: (Optional[str]) -> None
+        self._effect = new_val
+    
+    @property
+    def key(self):
+        # type: () -> str
+        return self._property_impl('key')
+    
+    @key.setter
+    def key(self, new_val):
+        # type: (Optional[str]) -> None
+        self._key = new_val
+    
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._property_impl('operator')
+    
+    @operator.setter
+    def operator(self, new_val):
+        # type: (Optional[str]) -> None
+        self._operator = new_val
+    
+    @property
+    def tolerationSeconds(self):
+        # type: () -> int
+        return self._property_impl('tolerationSeconds')
+    
+    @tolerationSeconds.setter
+    def tolerationSeconds(self, new_val):
+        # type: (Optional[int]) -> None
+        self._tolerationSeconds = new_val
+    
+    @property
+    def value(self):
+        # type: () -> str
+        return self._property_impl('value')
+    
+    @value.setter
+    def value(self, new_val):
+        # type: (Optional[str]) -> None
+        self._value = new_val
+
+
+class TolerationsList(CrdObjectList):
+    _items_type = TolerationsItem
+
+
+class TopologySpreadConstraintsItem(CrdObject):
+    _properties = [
+        ('labelSelector', 'labelSelector', 'LabelSelector', False, False),
+        ('maxSkew', 'maxSkew', int, True, False),
+        ('topologyKey', 'topologyKey', str, True, False),
+        ('whenUnsatisfiable', 'whenUnsatisfiable', str, True, False)
+    ]        
+
+    def __init__(self,
+                 maxSkew,  # type: int
+                 topologyKey,  # type: str
+                 whenUnsatisfiable,  # type: str
+                 labelSelector=_omit,  # type: Optional[LabelSelector]
+                 ):
+        super(TopologySpreadConstraintsItem, self).__init__(
+            maxSkew=maxSkew,
+            topologyKey=topologyKey,
+            whenUnsatisfiable=whenUnsatisfiable,
+            labelSelector=labelSelector,
+        )
+
+    @property
+    def labelSelector(self):
+        # type: () -> LabelSelector
+        return self._property_impl('labelSelector')
+    
+    @labelSelector.setter
+    def labelSelector(self, new_val):
+        # type: (Optional[LabelSelector]) -> None
+        self._labelSelector = new_val
+    
+    @property
+    def maxSkew(self):
+        # type: () -> int
+        return self._property_impl('maxSkew')
+    
+    @maxSkew.setter
+    def maxSkew(self, new_val):
+        # type: (int) -> None
+        self._maxSkew = new_val
+    
+    @property
+    def topologyKey(self):
+        # type: () -> str
+        return self._property_impl('topologyKey')
+    
+    @topologyKey.setter
+    def topologyKey(self, new_val):
+        # type: (str) -> None
+        self._topologyKey = new_val
+    
+    @property
+    def whenUnsatisfiable(self):
+        # type: () -> str
+        return self._property_impl('whenUnsatisfiable')
+    
+    @whenUnsatisfiable.setter
+    def whenUnsatisfiable(self, new_val):
+        # type: (str) -> None
+        self._whenUnsatisfiable = new_val
+
+
+class TopologySpreadConstraintsList(CrdObjectList):
+    _items_type = TopologySpreadConstraintsItem
+
+
+class Placement(CrdObject):
+    _properties = [
+        ('nodeAffinity', 'nodeAffinity', 'NodeAffinity', False, False),
+        ('podAffinity', 'podAffinity', 'PodAffinity', False, False),
+        ('podAntiAffinity', 'podAntiAffinity', 'PodAntiAffinity', False, False),
+        ('tolerations', 'tolerations', 'TolerationsList', False, False),
+        ('topologySpreadConstraints', 'topologySpreadConstraints', 'TopologySpreadConstraintsList', False, False)
+    ]        
+
+    def __init__(self,
+                 nodeAffinity=_omit,  # type: Optional[NodeAffinity]
+                 podAffinity=_omit,  # type: Optional[PodAffinity]
+                 podAntiAffinity=_omit,  # type: Optional[PodAntiAffinity]
+                 tolerations=_omit,  # type: Optional[Union[List[TolerationsItem], CrdObjectList]]
+                 topologySpreadConstraints=_omit,  # type: Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]
+                 ):
+        super(Placement, self).__init__(
+            nodeAffinity=nodeAffinity,
+            podAffinity=podAffinity,
+            podAntiAffinity=podAntiAffinity,
+            tolerations=tolerations,
+            topologySpreadConstraints=topologySpreadConstraints,
+        )
+
+    @property
+    def nodeAffinity(self):
+        # type: () -> NodeAffinity
+        return self._property_impl('nodeAffinity')
+    
+    @nodeAffinity.setter
+    def nodeAffinity(self, new_val):
+        # type: (Optional[NodeAffinity]) -> None
+        self._nodeAffinity = new_val
+    
+    @property
+    def podAffinity(self):
+        # type: () -> PodAffinity
+        return self._property_impl('podAffinity')
+    
+    @podAffinity.setter
+    def podAffinity(self, new_val):
+        # type: (Optional[PodAffinity]) -> None
+        self._podAffinity = new_val
+    
+    @property
+    def podAntiAffinity(self):
+        # type: () -> PodAntiAffinity
+        return self._property_impl('podAntiAffinity')
+    
+    @podAntiAffinity.setter
+    def podAntiAffinity(self, new_val):
+        # type: (Optional[PodAntiAffinity]) -> None
+        self._podAntiAffinity = new_val
+    
+    @property
+    def tolerations(self):
+        # type: () -> Union[List[TolerationsItem], CrdObjectList]
+        return self._property_impl('tolerations')
+    
+    @tolerations.setter
+    def tolerations(self, new_val):
+        # type: (Optional[Union[List[TolerationsItem], CrdObjectList]]) -> None
+        self._tolerations = new_val
+    
+    @property
+    def topologySpreadConstraints(self):
+        # type: () -> Union[List[TopologySpreadConstraintsItem], CrdObjectList]
+        return self._property_impl('topologySpreadConstraints')
+    
+    @topologySpreadConstraints.setter
+    def topologySpreadConstraints(self, new_val):
+        # type: (Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]) -> None
+        self._topologySpreadConstraints = new_val
+
+
+class Resources(CrdObject):
+    _properties = [
+        ('limits', 'limits', object, False, False),
+        ('requests', 'requests', object, False, False)
+    ]        
+
+    def __init__(self,
+                 limits=_omit,  # type: Optional[Any]
+                 requests=_omit,  # type: Optional[Any]
+                 ):
+        super(Resources, self).__init__(
+            limits=limits,
+            requests=requests,
+        )
+
+    @property
+    def limits(self):
+        # type: () -> Any
+        return self._property_impl('limits')
+    
+    @limits.setter
+    def limits(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._limits = new_val
+    
+    @property
+    def requests(self):
+        # type: () -> Any
+        return self._property_impl('requests')
+    
+    @requests.setter
+    def requests(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._requests = new_val
+
+
+class Service(CrdObject):
+    _properties = [
+        ('annotations', 'annotations', object, False, False)
+    ]        
+
+    def __init__(self,
+                 annotations=_omit,  # type: Optional[Any]
+                 ):
+        super(Service, self).__init__(
+            annotations=annotations,
+        )
+
+    @property
+    def annotations(self):
+        # type: () -> Any
+        return self._property_impl('annotations')
+    
+    @annotations.setter
+    def annotations(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._annotations = new_val
+
+
+class Gateway(CrdObject):
+    _properties = [
+        ('annotations', 'annotations', object, False, True),
+        ('externalRgwEndpoints', 'externalRgwEndpoints', 'ExternalRgwEndpointsList', False, True),
+        ('instances', 'instances', int, True, False),
+        ('labels', 'labels', object, False, True),
+        ('placement', 'placement', 'Placement', False, True),
+        ('port', 'port', int, False, False),
+        ('priorityClassName', 'priorityClassName', str, False, False),
+        ('resources', 'resources', 'Resources', False, True),
+        ('securePort', 'securePort', int, False, True),
+        ('service', 'service', 'Service', False, True),
+        ('sslCertificateRef', 'sslCertificateRef', str, False, True)
+    ]        
+
+    def __init__(self,
+                 instances,  # type: int
+                 annotations=_omit,  # type: Optional[Any]
+                 externalRgwEndpoints=_omit,  # type: Optional[Union[List[ExternalRgwEndpointsItem], CrdObjectList]]
+                 labels=_omit,  # type: Optional[Any]
+                 placement=_omit,  # type: Optional[Placement]
+                 port=_omit,  # type: Optional[int]
+                 priorityClassName=_omit,  # type: Optional[str]
+                 resources=_omit,  # type: Optional[Resources]
+                 securePort=_omit,  # type: Optional[int]
+                 service=_omit,  # type: Optional[Service]
+                 sslCertificateRef=_omit,  # type: Optional[str]
+                 ):
+        super(Gateway, self).__init__(
+            instances=instances,
+            annotations=annotations,
+            externalRgwEndpoints=externalRgwEndpoints,
+            labels=labels,
+            placement=placement,
+            port=port,
+            priorityClassName=priorityClassName,
+            resources=resources,
+            securePort=securePort,
+            service=service,
+            sslCertificateRef=sslCertificateRef,
+        )
+
+    @property
+    def annotations(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('annotations')
+    
+    @annotations.setter
+    def annotations(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._annotations = new_val
+    
+    @property
+    def externalRgwEndpoints(self):
+        # type: () -> Optional[Union[List[ExternalRgwEndpointsItem], CrdObjectList]]
+        return self._property_impl('externalRgwEndpoints')
+    
+    @externalRgwEndpoints.setter
+    def externalRgwEndpoints(self, new_val):
+        # type: (Optional[Union[List[ExternalRgwEndpointsItem], CrdObjectList]]) -> None
+        self._externalRgwEndpoints = new_val
+    
+    @property
+    def instances(self):
+        # type: () -> int
+        return self._property_impl('instances')
+    
+    @instances.setter
+    def instances(self, new_val):
+        # type: (int) -> None
+        self._instances = new_val
+    
+    @property
+    def labels(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('labels')
+    
+    @labels.setter
+    def labels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._labels = new_val
+    
+    @property
+    def placement(self):
+        # type: () -> Optional[Placement]
+        return self._property_impl('placement')
+    
+    @placement.setter
+    def placement(self, new_val):
+        # type: (Optional[Placement]) -> None
+        self._placement = new_val
+    
+    @property
+    def port(self):
+        # type: () -> int
+        return self._property_impl('port')
+    
+    @port.setter
+    def port(self, new_val):
+        # type: (Optional[int]) -> None
+        self._port = new_val
+    
+    @property
+    def priorityClassName(self):
+        # type: () -> str
+        return self._property_impl('priorityClassName')
+    
+    @priorityClassName.setter
+    def priorityClassName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._priorityClassName = new_val
+    
+    @property
+    def resources(self):
+        # type: () -> Optional[Resources]
+        return self._property_impl('resources')
+    
+    @resources.setter
+    def resources(self, new_val):
+        # type: (Optional[Resources]) -> None
+        self._resources = new_val
+    
+    @property
+    def securePort(self):
+        # type: () -> Optional[int]
+        return self._property_impl('securePort')
+    
+    @securePort.setter
+    def securePort(self, new_val):
+        # type: (Optional[int]) -> None
+        self._securePort = new_val
+    
+    @property
+    def service(self):
+        # type: () -> Optional[Service]
+        return self._property_impl('service')
+    
+    @service.setter
+    def service(self, new_val):
+        # type: (Optional[Service]) -> None
+        self._service = new_val
+    
+    @property
+    def sslCertificateRef(self):
+        # type: () -> Optional[str]
+        return self._property_impl('sslCertificateRef')
+    
+    @sslCertificateRef.setter
+    def sslCertificateRef(self, new_val):
+        # type: (Optional[str]) -> None
+        self._sslCertificateRef = new_val
+
+
+class Bucket(CrdObject):
+    _properties = [
+        ('disabled', 'disabled', bool, False, False),
+        ('interval', 'interval', str, False, False),
+        ('timeout', 'timeout', str, False, False)
+    ]        
+
+    def __init__(self,
+                 disabled=_omit,  # type: Optional[bool]
+                 interval=_omit,  # type: Optional[str]
+                 timeout=_omit,  # type: Optional[str]
+                 ):
+        super(Bucket, self).__init__(
+            disabled=disabled,
+            interval=interval,
+            timeout=timeout,
+        )
+
+    @property
+    def disabled(self):
+        # type: () -> bool
+        return self._property_impl('disabled')
+    
+    @disabled.setter
+    def disabled(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._disabled = new_val
+    
+    @property
+    def interval(self):
+        # type: () -> str
+        return self._property_impl('interval')
+    
+    @interval.setter
+    def interval(self, new_val):
+        # type: (Optional[str]) -> None
+        self._interval = new_val
+    
+    @property
+    def timeout(self):
+        # type: () -> str
+        return self._property_impl('timeout')
+    
+    @timeout.setter
+    def timeout(self, new_val):
+        # type: (Optional[str]) -> None
+        self._timeout = new_val
+
+
+class CommandList(CrdObjectList):
+    _items_type = str
+
+
+class Exec(CrdObject):
+    _properties = [
+        ('command', 'command', 'CommandList', False, False)
+    ]        
+
+    def __init__(self,
+                 command=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(Exec, self).__init__(
+            command=command,
+        )
+
+    @property
+    def command(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('command')
+    
+    @command.setter
+    def command(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._command = new_val
+
+
+class HttpHeadersItem(CrdObject):
+    _properties = [
+        ('name', 'name', str, True, False),
+        ('value', 'value', str, True, False)
+    ]        
+
+    def __init__(self,
+                 name,  # type: str
+                 value,  # type: str
+                 ):
+        super(HttpHeadersItem, self).__init__(
+            name=name,
+            value=value,
+        )
+
+    @property
+    def name(self):
+        # type: () -> str
+        return self._property_impl('name')
+    
+    @name.setter
+    def name(self, new_val):
+        # type: (str) -> None
+        self._name = new_val
+    
+    @property
+    def value(self):
+        # type: () -> str
+        return self._property_impl('value')
+    
+    @value.setter
+    def value(self, new_val):
+        # type: (str) -> None
+        self._value = new_val
+
+
+class HttpHeadersList(CrdObjectList):
+    _items_type = HttpHeadersItem
+
+
+class HttpGet(CrdObject):
+    _properties = [
+        ('host', 'host', str, False, False),
+        ('httpHeaders', 'httpHeaders', 'HttpHeadersList', False, False),
+        ('path', 'path', str, False, False),
+        ('port', 'port', Union[int, str], True, False),
+        ('scheme', 'scheme', str, False, False)
+    ]        
+
+    def __init__(self,
+                 port,  # type: Union[int, str]
+                 host=_omit,  # type: Optional[str]
+                 httpHeaders=_omit,  # type: Optional[Union[List[HttpHeadersItem], CrdObjectList]]
+                 path=_omit,  # type: Optional[str]
+                 scheme=_omit,  # type: Optional[str]
+                 ):
+        super(HttpGet, self).__init__(
+            port=port,
+            host=host,
+            httpHeaders=httpHeaders,
+            path=path,
+            scheme=scheme,
+        )
+
+    @property
+    def host(self):
+        # type: () -> str
+        return self._property_impl('host')
+    
+    @host.setter
+    def host(self, new_val):
+        # type: (Optional[str]) -> None
+        self._host = new_val
+    
+    @property
+    def httpHeaders(self):
+        # type: () -> Union[List[HttpHeadersItem], CrdObjectList]
+        return self._property_impl('httpHeaders')
+    
+    @httpHeaders.setter
+    def httpHeaders(self, new_val):
+        # type: (Optional[Union[List[HttpHeadersItem], CrdObjectList]]) -> None
+        self._httpHeaders = new_val
+    
+    @property
+    def path(self):
+        # type: () -> str
+        return self._property_impl('path')
+    
+    @path.setter
+    def path(self, new_val):
+        # type: (Optional[str]) -> None
+        self._path = new_val
+    
+    @property
+    def port(self):
+        # type: () -> Union[int, str]
+        return self._property_impl('port')
+    
+    @port.setter
+    def port(self, new_val):
+        # type: (Union[int, str]) -> None
+        self._port = new_val
+    
+    @property
+    def scheme(self):
+        # type: () -> str
+        return self._property_impl('scheme')
+    
+    @scheme.setter
+    def scheme(self, new_val):
+        # type: (Optional[str]) -> None
+        self._scheme = new_val
+
+
+class TcpSocket(CrdObject):
+    _properties = [
+        ('host', 'host', str, False, False),
+        ('port', 'port', Union[int, str], True, False)
+    ]        
+
+    def __init__(self,
+                 port,  # type: Union[int, str]
+                 host=_omit,  # type: Optional[str]
+                 ):
+        super(TcpSocket, self).__init__(
+            port=port,
+            host=host,
+        )
+
+    @property
+    def host(self):
+        # type: () -> str
+        return self._property_impl('host')
+    
+    @host.setter
+    def host(self, new_val):
+        # type: (Optional[str]) -> None
+        self._host = new_val
+    
+    @property
+    def port(self):
+        # type: () -> Union[int, str]
+        return self._property_impl('port')
+    
+    @port.setter
+    def port(self, new_val):
+        # type: (Union[int, str]) -> None
+        self._port = new_val
+
+
+class Probe(CrdObject):
+    _properties = [
+        ('exec', 'exec_1', 'Exec', False, False),
+        ('failureThreshold', 'failureThreshold', int, False, False),
+        ('httpGet', 'httpGet', 'HttpGet', False, False),
+        ('initialDelaySeconds', 'initialDelaySeconds', int, False, False),
+        ('periodSeconds', 'periodSeconds', int, False, False),
+        ('successThreshold', 'successThreshold', int, False, False),
+        ('tcpSocket', 'tcpSocket', 'TcpSocket', False, False),
+        ('terminationGracePeriodSeconds', 'terminationGracePeriodSeconds', int, False, False),
+        ('timeoutSeconds', 'timeoutSeconds', int, False, False)
+    ]        
+
+    def __init__(self,
+                 exec_1=_omit,  # type: Optional[Exec]
+                 failureThreshold=_omit,  # type: Optional[int]
+                 httpGet=_omit,  # type: Optional[HttpGet]
+                 initialDelaySeconds=_omit,  # type: Optional[int]
+                 periodSeconds=_omit,  # type: Optional[int]
+                 successThreshold=_omit,  # type: Optional[int]
+                 tcpSocket=_omit,  # type: Optional[TcpSocket]
+                 terminationGracePeriodSeconds=_omit,  # type: Optional[int]
+                 timeoutSeconds=_omit,  # type: Optional[int]
+                 ):
+        super(Probe, self).__init__(
+            exec_1=exec_1,
+            failureThreshold=failureThreshold,
+            httpGet=httpGet,
+            initialDelaySeconds=initialDelaySeconds,
+            periodSeconds=periodSeconds,
+            successThreshold=successThreshold,
+            tcpSocket=tcpSocket,
+            terminationGracePeriodSeconds=terminationGracePeriodSeconds,
+            timeoutSeconds=timeoutSeconds,
+        )
+
+    @property
+    def exec_1(self):
+        # type: () -> Exec
+        return self._property_impl('exec_1')
+    
+    @exec_1.setter
+    def exec_1(self, new_val):
+        # type: (Optional[Exec]) -> None
+        self._exec_1 = new_val
+    
+    @property
+    def failureThreshold(self):
+        # type: () -> int
+        return self._property_impl('failureThreshold')
+    
+    @failureThreshold.setter
+    def failureThreshold(self, new_val):
+        # type: (Optional[int]) -> None
+        self._failureThreshold = new_val
+    
+    @property
+    def httpGet(self):
+        # type: () -> HttpGet
+        return self._property_impl('httpGet')
+    
+    @httpGet.setter
+    def httpGet(self, new_val):
+        # type: (Optional[HttpGet]) -> None
+        self._httpGet = new_val
+    
+    @property
+    def initialDelaySeconds(self):
+        # type: () -> int
+        return self._property_impl('initialDelaySeconds')
+    
+    @initialDelaySeconds.setter
+    def initialDelaySeconds(self, new_val):
+        # type: (Optional[int]) -> None
+        self._initialDelaySeconds = new_val
+    
+    @property
+    def periodSeconds(self):
+        # type: () -> int
+        return self._property_impl('periodSeconds')
+    
+    @periodSeconds.setter
+    def periodSeconds(self, new_val):
+        # type: (Optional[int]) -> None
+        self._periodSeconds = new_val
+    
+    @property
+    def successThreshold(self):
+        # type: () -> int
+        return self._property_impl('successThreshold')
+    
+    @successThreshold.setter
+    def successThreshold(self, new_val):
+        # type: (Optional[int]) -> None
+        self._successThreshold = new_val
+    
+    @property
+    def tcpSocket(self):
+        # type: () -> TcpSocket
+        return self._property_impl('tcpSocket')
+    
+    @tcpSocket.setter
+    def tcpSocket(self, new_val):
+        # type: (Optional[TcpSocket]) -> None
+        self._tcpSocket = new_val
+    
+    @property
+    def terminationGracePeriodSeconds(self):
+        # type: () -> int
+        return self._property_impl('terminationGracePeriodSeconds')
+    
+    @terminationGracePeriodSeconds.setter
+    def terminationGracePeriodSeconds(self, new_val):
+        # type: (Optional[int]) -> None
+        self._terminationGracePeriodSeconds = new_val
+    
+    @property
+    def timeoutSeconds(self):
+        # type: () -> int
+        return self._property_impl('timeoutSeconds')
+    
+    @timeoutSeconds.setter
+    def timeoutSeconds(self, new_val):
+        # type: (Optional[int]) -> None
+        self._timeoutSeconds = new_val
+
+
+class LivenessProbe(CrdObject):
+    _properties = [
+        ('disabled', 'disabled', bool, False, False),
+        ('probe', 'probe', 'Probe', False, False)
+    ]        
+
+    def __init__(self,
+                 disabled=_omit,  # type: Optional[bool]
+                 probe=_omit,  # type: Optional[Probe]
+                 ):
+        super(LivenessProbe, self).__init__(
+            disabled=disabled,
+            probe=probe,
+        )
+
+    @property
+    def disabled(self):
+        # type: () -> bool
+        return self._property_impl('disabled')
+    
+    @disabled.setter
+    def disabled(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._disabled = new_val
+    
+    @property
+    def probe(self):
+        # type: () -> Probe
+        return self._property_impl('probe')
+    
+    @probe.setter
+    def probe(self, new_val):
+        # type: (Optional[Probe]) -> None
+        self._probe = new_val
+
+
+class HealthCheck(CrdObject):
+    _properties = [
+        ('bucket', 'bucket', 'Bucket', False, False),
+        ('livenessProbe', 'livenessProbe', 'LivenessProbe', False, False)
+    ]        
+
+    def __init__(self,
+                 bucket=_omit,  # type: Optional[Bucket]
+                 livenessProbe=_omit,  # type: Optional[LivenessProbe]
+                 ):
+        super(HealthCheck, self).__init__(
+            bucket=bucket,
+            livenessProbe=livenessProbe,
+        )
+
+    @property
+    def bucket(self):
+        # type: () -> Bucket
+        return self._property_impl('bucket')
+    
+    @bucket.setter
+    def bucket(self, new_val):
+        # type: (Optional[Bucket]) -> None
+        self._bucket = new_val
+    
+    @property
+    def livenessProbe(self):
+        # type: () -> LivenessProbe
+        return self._property_impl('livenessProbe')
+    
+    @livenessProbe.setter
+    def livenessProbe(self, new_val):
+        # type: (Optional[LivenessProbe]) -> None
+        self._livenessProbe = new_val
+
+
+class MetadataPool(CrdObject):
+    _properties = [
+        ('compressionMode', 'compressionMode', str, False, True),
+        ('crushRoot', 'crushRoot', str, False, True),
+        ('deviceClass', 'deviceClass', str, False, True),
+        ('enableRBDStats', 'enableRBDStats', bool, False, False),
+        ('erasureCoded', 'erasureCoded', 'ErasureCoded', False, False),
+        ('failureDomain', 'failureDomain', str, False, False),
+        ('mirroring', 'mirroring', 'Mirroring', False, False),
+        ('parameters', 'parameters', object, False, True),
+        ('quotas', 'quotas', 'Quotas', False, True),
+        ('replicated', 'replicated', 'Replicated', False, False),
+        ('statusCheck', 'statusCheck', 'StatusCheck', False, False)
+    ]        
+
+    def __init__(self,
+                 compressionMode=_omit,  # type: Optional[str]
+                 crushRoot=_omit,  # type: Optional[str]
+                 deviceClass=_omit,  # type: Optional[str]
+                 enableRBDStats=_omit,  # type: Optional[bool]
+                 erasureCoded=_omit,  # type: Optional[ErasureCoded]
+                 failureDomain=_omit,  # type: Optional[str]
+                 mirroring=_omit,  # type: Optional[Mirroring]
+                 parameters=_omit,  # type: Optional[Any]
+                 quotas=_omit,  # type: Optional[Quotas]
+                 replicated=_omit,  # type: Optional[Replicated]
+                 statusCheck=_omit,  # type: Optional[StatusCheck]
+                 ):
+        super(MetadataPool, self).__init__(
+            compressionMode=compressionMode,
+            crushRoot=crushRoot,
+            deviceClass=deviceClass,
+            enableRBDStats=enableRBDStats,
+            erasureCoded=erasureCoded,
+            failureDomain=failureDomain,
+            mirroring=mirroring,
+            parameters=parameters,
+            quotas=quotas,
+            replicated=replicated,
+            statusCheck=statusCheck,
+        )
+
+    @property
+    def compressionMode(self):
+        # type: () -> Optional[str]
+        return self._property_impl('compressionMode')
+    
+    @compressionMode.setter
+    def compressionMode(self, new_val):
+        # type: (Optional[str]) -> None
+        self._compressionMode = new_val
+    
+    @property
+    def crushRoot(self):
+        # type: () -> Optional[str]
+        return self._property_impl('crushRoot')
+    
+    @crushRoot.setter
+    def crushRoot(self, new_val):
+        # type: (Optional[str]) -> None
+        self._crushRoot = new_val
+    
+    @property
+    def deviceClass(self):
+        # type: () -> Optional[str]
+        return self._property_impl('deviceClass')
+    
+    @deviceClass.setter
+    def deviceClass(self, new_val):
+        # type: (Optional[str]) -> None
+        self._deviceClass = new_val
+    
+    @property
+    def enableRBDStats(self):
+        # type: () -> bool
+        return self._property_impl('enableRBDStats')
+    
+    @enableRBDStats.setter
+    def enableRBDStats(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._enableRBDStats = new_val
+    
+    @property
+    def erasureCoded(self):
+        # type: () -> ErasureCoded
+        return self._property_impl('erasureCoded')
+    
+    @erasureCoded.setter
+    def erasureCoded(self, new_val):
+        # type: (Optional[ErasureCoded]) -> None
+        self._erasureCoded = new_val
+    
+    @property
+    def failureDomain(self):
+        # type: () -> str
+        return self._property_impl('failureDomain')
+    
+    @failureDomain.setter
+    def failureDomain(self, new_val):
+        # type: (Optional[str]) -> None
+        self._failureDomain = new_val
+    
+    @property
+    def mirroring(self):
+        # type: () -> Mirroring
+        return self._property_impl('mirroring')
+    
+    @mirroring.setter
+    def mirroring(self, new_val):
+        # type: (Optional[Mirroring]) -> None
+        self._mirroring = new_val
+    
+    @property
+    def parameters(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('parameters')
+    
+    @parameters.setter
+    def parameters(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._parameters = new_val
+    
+    @property
+    def quotas(self):
+        # type: () -> Optional[Quotas]
+        return self._property_impl('quotas')
+    
+    @quotas.setter
+    def quotas(self, new_val):
+        # type: (Optional[Quotas]) -> None
+        self._quotas = new_val
+    
+    @property
+    def replicated(self):
+        # type: () -> Replicated
+        return self._property_impl('replicated')
+    
+    @replicated.setter
+    def replicated(self, new_val):
+        # type: (Optional[Replicated]) -> None
+        self._replicated = new_val
+    
+    @property
+    def statusCheck(self):
+        # type: () -> StatusCheck
+        return self._property_impl('statusCheck')
+    
+    @statusCheck.setter
+    def statusCheck(self, new_val):
+        # type: (Optional[StatusCheck]) -> None
+        self._statusCheck = new_val
+
+
+class Kms(CrdObject):
+    _properties = [
+        ('connectionDetails', 'connectionDetails', object, False, True),
+        ('tokenSecretName', 'tokenSecretName', str, False, False)
+    ]        
+
+    def __init__(self,
+                 connectionDetails=_omit,  # type: Optional[Any]
+                 tokenSecretName=_omit,  # type: Optional[str]
+                 ):
+        super(Kms, self).__init__(
+            connectionDetails=connectionDetails,
+            tokenSecretName=tokenSecretName,
+        )
+
+    @property
+    def connectionDetails(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('connectionDetails')
+    
+    @connectionDetails.setter
+    def connectionDetails(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._connectionDetails = new_val
+    
+    @property
+    def tokenSecretName(self):
+        # type: () -> str
+        return self._property_impl('tokenSecretName')
+    
+    @tokenSecretName.setter
+    def tokenSecretName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._tokenSecretName = new_val
+
+
+class Security(CrdObject):
+    _properties = [
+        ('kms', 'kms', 'Kms', False, True)
+    ]        
+
+    def __init__(self,
+                 kms=_omit,  # type: Optional[Kms]
+                 ):
+        super(Security, self).__init__(
+            kms=kms,
+        )
+
+    @property
+    def kms(self):
+        # type: () -> Optional[Kms]
+        return self._property_impl('kms')
+    
+    @kms.setter
+    def kms(self, new_val):
+        # type: (Optional[Kms]) -> None
+        self._kms = new_val
+
+
+class Zone(CrdObject):
+    _properties = [
+        ('name', 'name', str, True, False)
+    ]        
+
+    def __init__(self,
+                 name,  # type: str
+                 ):
+        super(Zone, self).__init__(
+            name=name,
+        )
+
+    @property
+    def name(self):
+        # type: () -> str
+        return self._property_impl('name')
+    
+    @name.setter
+    def name(self, new_val):
+        # type: (str) -> None
+        self._name = new_val
+
+
+class Spec(CrdObject):
+    _properties = [
+        ('dataPool', 'dataPool', 'DataPool', False, True),
+        ('gateway', 'gateway', 'Gateway', False, True),
+        ('healthCheck', 'healthCheck', 'HealthCheck', False, True),
+        ('metadataPool', 'metadataPool', 'MetadataPool', False, True),
+        ('preservePoolsOnDelete', 'preservePoolsOnDelete', bool, False, False),
+        ('security', 'security', 'Security', False, True),
+        ('zone', 'zone', 'Zone', False, True)
+    ]        
+
+    def __init__(self,
+                 dataPool=_omit,  # type: Optional[DataPool]
+                 gateway=_omit,  # type: Optional[Gateway]
+                 healthCheck=_omit,  # type: Optional[HealthCheck]
+                 metadataPool=_omit,  # type: Optional[MetadataPool]
+                 preservePoolsOnDelete=_omit,  # type: Optional[bool]
+                 security=_omit,  # type: Optional[Security]
+                 zone=_omit,  # type: Optional[Zone]
+                 ):
+        super(Spec, self).__init__(
+            dataPool=dataPool,
+            gateway=gateway,
+            healthCheck=healthCheck,
+            metadataPool=metadataPool,
+            preservePoolsOnDelete=preservePoolsOnDelete,
+            security=security,
+            zone=zone,
+        )
+
+    @property
+    def dataPool(self):
+        # type: () -> Optional[DataPool]
+        return self._property_impl('dataPool')
+    
+    @dataPool.setter
+    def dataPool(self, new_val):
+        # type: (Optional[DataPool]) -> None
+        self._dataPool = new_val
+    
+    @property
+    def gateway(self):
+        # type: () -> Optional[Gateway]
+        return self._property_impl('gateway')
+    
+    @gateway.setter
+    def gateway(self, new_val):
+        # type: (Optional[Gateway]) -> None
+        self._gateway = new_val
+    
+    @property
+    def healthCheck(self):
+        # type: () -> Optional[HealthCheck]
+        return self._property_impl('healthCheck')
+    
+    @healthCheck.setter
+    def healthCheck(self, new_val):
+        # type: (Optional[HealthCheck]) -> None
+        self._healthCheck = new_val
+    
+    @property
+    def metadataPool(self):
+        # type: () -> Optional[MetadataPool]
+        return self._property_impl('metadataPool')
+    
+    @metadataPool.setter
+    def metadataPool(self, new_val):
+        # type: (Optional[MetadataPool]) -> None
+        self._metadataPool = new_val
+    
+    @property
+    def preservePoolsOnDelete(self):
+        # type: () -> bool
+        return self._property_impl('preservePoolsOnDelete')
+    
+    @preservePoolsOnDelete.setter
+    def preservePoolsOnDelete(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._preservePoolsOnDelete = new_val
+    
+    @property
+    def security(self):
+        # type: () -> Optional[Security]
+        return self._property_impl('security')
+    
+    @security.setter
+    def security(self, new_val):
+        # type: (Optional[Security]) -> None
+        self._security = new_val
+    
+    @property
+    def zone(self):
+        # type: () -> Optional[Zone]
+        return self._property_impl('zone')
+    
+    @zone.setter
+    def zone(self, new_val):
+        # type: (Optional[Zone]) -> None
+        self._zone = new_val
+
+
+class BucketStatus(CrdObject):
+    _properties = [
+        ('details', 'details', str, False, False),
+        ('health', 'health', str, False, False),
+        ('lastChanged', 'lastChanged', str, False, False),
+        ('lastChecked', 'lastChecked', str, False, False)
+    ]        
+
+    def __init__(self,
+                 details=_omit,  # type: Optional[str]
+                 health=_omit,  # type: Optional[str]
+                 lastChanged=_omit,  # type: Optional[str]
+                 lastChecked=_omit,  # type: Optional[str]
+                 ):
+        super(BucketStatus, self).__init__(
+            details=details,
+            health=health,
+            lastChanged=lastChanged,
+            lastChecked=lastChecked,
+        )
+
+    @property
+    def details(self):
+        # type: () -> str
+        return self._property_impl('details')
+    
+    @details.setter
+    def details(self, new_val):
+        # type: (Optional[str]) -> None
+        self._details = new_val
+    
+    @property
+    def health(self):
+        # type: () -> str
+        return self._property_impl('health')
+    
+    @health.setter
+    def health(self, new_val):
+        # type: (Optional[str]) -> None
+        self._health = new_val
+    
+    @property
+    def lastChanged(self):
+        # type: () -> str
+        return self._property_impl('lastChanged')
+    
+    @lastChanged.setter
+    def lastChanged(self, new_val):
+        # type: (Optional[str]) -> None
+        self._lastChanged = new_val
+    
+    @property
+    def lastChecked(self):
+        # type: () -> str
+        return self._property_impl('lastChecked')
+    
+    @lastChecked.setter
+    def lastChecked(self, new_val):
+        # type: (Optional[str]) -> None
+        self._lastChecked = new_val
+
+
+class Status(CrdObject):
+    _properties = [
+        ('bucketStatus', 'bucketStatus', 'BucketStatus', False, False),
+        ('info', 'info', object, False, True),
+        ('message', 'message', str, False, False),
+        ('phase', 'phase', str, False, False)
+    ]        
+
+    def __init__(self,
+                 bucketStatus=_omit,  # type: Optional[BucketStatus]
+                 info=_omit,  # type: Optional[Any]
+                 message=_omit,  # type: Optional[str]
+                 phase=_omit,  # type: Optional[str]
+                 ):
+        super(Status, self).__init__(
+            bucketStatus=bucketStatus,
+            info=info,
+            message=message,
+            phase=phase,
+        )
+
+    @property
+    def bucketStatus(self):
+        # type: () -> BucketStatus
+        return self._property_impl('bucketStatus')
+    
+    @bucketStatus.setter
+    def bucketStatus(self, new_val):
+        # type: (Optional[BucketStatus]) -> None
+        self._bucketStatus = new_val
+    
+    @property
+    def info(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('info')
+    
+    @info.setter
+    def info(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._info = new_val
+    
+    @property
+    def message(self):
+        # type: () -> str
+        return self._property_impl('message')
+    
+    @message.setter
+    def message(self, new_val):
+        # type: (Optional[str]) -> None
+        self._message = new_val
+    
+    @property
+    def phase(self):
+        # type: () -> str
+        return self._property_impl('phase')
+    
+    @phase.setter
+    def phase(self, new_val):
+        # type: (Optional[str]) -> None
+        self._phase = new_val
+
+
+class CephObjectStore(CrdClass):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('kind', 'kind', str, False, False),
+        ('metadata', 'metadata', object, False, False),
+        ('spec', 'spec', 'Spec', True, False),
+        ('status', 'status', 'Status', False, False)
+    ]        
+
+    def __init__(self,
+                 spec,  # type: Spec
+                 apiVersion=_omit,  # type: Optional[str]
+                 kind=_omit,  # type: Optional[str]
+                 metadata=_omit,  # type: Optional[Any]
+                 status=_omit,  # type: Optional[Status]
+                 ):
+        super(CephObjectStore, self).__init__(
+            spec=spec,
+            apiVersion=apiVersion,
+            kind=kind,
+            metadata=metadata,
+            status=status,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Any
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._metadata = new_val
+    
+    @property
+    def spec(self):
+        # type: () -> Spec
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Spec) -> None
+        self._spec = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Status
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Status]) -> None
+        self._status = new_val
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectstoreuser.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectstoreuser.py
new file mode 100644
index 000000000..5947aaa4f
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectstoreuser.py
@@ -0,0 +1,157 @@
+"""
+This file is automatically generated.
+Do not modify.
+"""
+
+try:
+    from typing import Any, Optional, Union, List
+except ImportError:
+    pass
+
+from .._helper import _omit, CrdObject, CrdObjectList, CrdClass
+
+class Spec(CrdObject):
+    _properties = [
+        ('displayName', 'displayName', str, False, False),
+        ('store', 'store', str, False, False)
+    ]        
+
+    def __init__(self,
+                 displayName=_omit,  # type: Optional[str]
+                 store=_omit,  # type: Optional[str]
+                 ):
+        super(Spec, self).__init__(
+            displayName=displayName,
+            store=store,
+        )
+
+    @property
+    def displayName(self):
+        # type: () -> str
+        return self._property_impl('displayName')
+    
+    @displayName.setter
+    def displayName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._displayName = new_val
+    
+    @property
+    def store(self):
+        # type: () -> str
+        return self._property_impl('store')
+    
+    @store.setter
+    def store(self, new_val):
+        # type: (Optional[str]) -> None
+        self._store = new_val
+
+
+class Status(CrdObject):
+    _properties = [
+        ('info', 'info', object, False, True),
+        ('phase', 'phase', str, False, False)
+    ]        
+
+    def __init__(self,
+                 info=_omit,  # type: Optional[Any]
+                 phase=_omit,  # type: Optional[str]
+                 ):
+        super(Status, self).__init__(
+            info=info,
+            phase=phase,
+        )
+
+    @property
+    def info(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('info')
+    
+    @info.setter
+    def info(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._info = new_val
+    
+    @property
+    def phase(self):
+        # type: () -> str
+        return self._property_impl('phase')
+    
+    @phase.setter
+    def phase(self, new_val):
+        # type: (Optional[str]) -> None
+        self._phase = new_val
+
+
+class CephObjectStoreUser(CrdClass):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('kind', 'kind', str, False, False),
+        ('metadata', 'metadata', object, False, False),
+        ('spec', 'spec', 'Spec', True, False),
+        ('status', 'status', 'Status', False, False)
+    ]        
+
+    def __init__(self,
+                 spec,  # type: Spec
+                 apiVersion=_omit,  # type: Optional[str]
+                 kind=_omit,  # type: Optional[str]
+                 metadata=_omit,  # type: Optional[Any]
+                 status=_omit,  # type: Optional[Status]
+                 ):
+        super(CephObjectStoreUser, self).__init__(
+            spec=spec,
+            apiVersion=apiVersion,
+            kind=kind,
+            metadata=metadata,
+            status=status,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Any
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._metadata = new_val
+    
+    @property
+    def spec(self):
+        # type: () -> Spec
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Spec) -> None
+        self._spec = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Status
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Status]) -> None
+        self._status = new_val
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectzone.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectzone.py
new file mode 100644
index 000000000..7ba5f510f
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectzone.py
@@ -0,0 +1,797 @@
+"""
+This file is automatically generated.
+Do not modify.
+"""
+
+try:
+    from typing import Any, Optional, Union, List
+except ImportError:
+    pass
+
+from .._helper import _omit, CrdObject, CrdObjectList, CrdClass
+
+class ErasureCoded(CrdObject):
+    _properties = [
+        ('algorithm', 'algorithm', str, False, False),
+        ('codingChunks', 'codingChunks', int, True, False),
+        ('dataChunks', 'dataChunks', int, True, False)
+    ]        
+
+    def __init__(self,
+                 codingChunks,  # type: int
+                 dataChunks,  # type: int
+                 algorithm=_omit,  # type: Optional[str]
+                 ):
+        super(ErasureCoded, self).__init__(
+            codingChunks=codingChunks,
+            dataChunks=dataChunks,
+            algorithm=algorithm,
+        )
+
+    @property
+    def algorithm(self):
+        # type: () -> str
+        return self._property_impl('algorithm')
+    
+    @algorithm.setter
+    def algorithm(self, new_val):
+        # type: (Optional[str]) -> None
+        self._algorithm = new_val
+    
+    @property
+    def codingChunks(self):
+        # type: () -> int
+        return self._property_impl('codingChunks')
+    
+    @codingChunks.setter
+    def codingChunks(self, new_val):
+        # type: (int) -> None
+        self._codingChunks = new_val
+    
+    @property
+    def dataChunks(self):
+        # type: () -> int
+        return self._property_impl('dataChunks')
+    
+    @dataChunks.setter
+    def dataChunks(self, new_val):
+        # type: (int) -> None
+        self._dataChunks = new_val
+
+
+class SnapshotSchedulesItem(CrdObject):
+    _properties = [
+        ('interval', 'interval', str, False, False),
+        ('startTime', 'startTime', str, False, False)
+    ]        
+
+    def __init__(self,
+                 interval=_omit,  # type: Optional[str]
+                 startTime=_omit,  # type: Optional[str]
+                 ):
+        super(SnapshotSchedulesItem, self).__init__(
+            interval=interval,
+            startTime=startTime,
+        )
+
+    @property
+    def interval(self):
+        # type: () -> str
+        return self._property_impl('interval')
+    
+    @interval.setter
+    def interval(self, new_val):
+        # type: (Optional[str]) -> None
+        self._interval = new_val
+    
+    @property
+    def startTime(self):
+        # type: () -> str
+        return self._property_impl('startTime')
+    
+    @startTime.setter
+    def startTime(self, new_val):
+        # type: (Optional[str]) -> None
+        self._startTime = new_val
+
+
+class SnapshotSchedulesList(CrdObjectList):
+    _items_type = SnapshotSchedulesItem
+
+
+class Mirroring(CrdObject):
+    _properties = [
+        ('enabled', 'enabled', bool, False, False),
+        ('mode', 'mode', str, False, False),
+        ('snapshotSchedules', 'snapshotSchedules', 'SnapshotSchedulesList', False, False)
+    ]        
+
+    def __init__(self,
+                 enabled=_omit,  # type: Optional[bool]
+                 mode=_omit,  # type: Optional[str]
+                 snapshotSchedules=_omit,  # type: Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]]
+                 ):
+        super(Mirroring, self).__init__(
+            enabled=enabled,
+            mode=mode,
+            snapshotSchedules=snapshotSchedules,
+        )
+
+    @property
+    def enabled(self):
+        # type: () -> bool
+        return self._property_impl('enabled')
+    
+    @enabled.setter
+    def enabled(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._enabled = new_val
+    
+    @property
+    def mode(self):
+        # type: () -> str
+        return self._property_impl('mode')
+    
+    @mode.setter
+    def mode(self, new_val):
+        # type: (Optional[str]) -> None
+        self._mode = new_val
+    
+    @property
+    def snapshotSchedules(self):
+        # type: () -> Union[List[SnapshotSchedulesItem], CrdObjectList]
+        return self._property_impl('snapshotSchedules')
+    
+    @snapshotSchedules.setter
+    def snapshotSchedules(self, new_val):
+        # type: (Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]]) -> None
+        self._snapshotSchedules = new_val
+
+
+class Quotas(CrdObject):
+    _properties = [
+        ('maxBytes', 'maxBytes', int, False, False),
+        ('maxObjects', 'maxObjects', int, False, False),
+        ('maxSize', 'maxSize', str, False, False)
+    ]        
+
+    def __init__(self,
+                 maxBytes=_omit,  # type: Optional[int]
+                 maxObjects=_omit,  # type: Optional[int]
+                 maxSize=_omit,  # type: Optional[str]
+                 ):
+        super(Quotas, self).__init__(
+            maxBytes=maxBytes,
+            maxObjects=maxObjects,
+            maxSize=maxSize,
+        )
+
+    @property
+    def maxBytes(self):
+        # type: () -> int
+        return self._property_impl('maxBytes')
+    
+    @maxBytes.setter
+    def maxBytes(self, new_val):
+        # type: (Optional[int]) -> None
+        self._maxBytes = new_val
+    
+    @property
+    def maxObjects(self):
+        # type: () -> int
+        return self._property_impl('maxObjects')
+    
+    @maxObjects.setter
+    def maxObjects(self, new_val):
+        # type: (Optional[int]) -> None
+        self._maxObjects = new_val
+    
+    @property
+    def maxSize(self):
+        # type: () -> str
+        return self._property_impl('maxSize')
+    
+    @maxSize.setter
+    def maxSize(self, new_val):
+        # type: (Optional[str]) -> None
+        self._maxSize = new_val
+
+
+class Replicated(CrdObject):
+    _properties = [
+        ('replicasPerFailureDomain', 'replicasPerFailureDomain', int, False, False),
+        ('requireSafeReplicaSize', 'requireSafeReplicaSize', bool, False, False),
+        ('size', 'size', int, True, False),
+        ('subFailureDomain', 'subFailureDomain', str, False, False),
+        ('targetSizeRatio', 'targetSizeRatio', float, False, False)
+    ]        
+
+    def __init__(self,
+                 size,  # type: int
+                 replicasPerFailureDomain=_omit,  # type: Optional[int]
+                 requireSafeReplicaSize=_omit,  # type: Optional[bool]
+                 subFailureDomain=_omit,  # type: Optional[str]
+                 targetSizeRatio=_omit,  # type: Optional[float]
+                 ):
+        super(Replicated, self).__init__(
+            size=size,
+            replicasPerFailureDomain=replicasPerFailureDomain,
+            requireSafeReplicaSize=requireSafeReplicaSize,
+            subFailureDomain=subFailureDomain,
+            targetSizeRatio=targetSizeRatio,
+        )
+
+    @property
+    def replicasPerFailureDomain(self):
+        # type: () -> int
+        return self._property_impl('replicasPerFailureDomain')
+    
+    @replicasPerFailureDomain.setter
+    def replicasPerFailureDomain(self, new_val):
+        # type: (Optional[int]) -> None
+        self._replicasPerFailureDomain = new_val
+    
+    @property
+    def requireSafeReplicaSize(self):
+        # type: () -> bool
+        return self._property_impl('requireSafeReplicaSize')
+    
+    @requireSafeReplicaSize.setter
+    def requireSafeReplicaSize(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._requireSafeReplicaSize = new_val
+    
+    @property
+    def size(self):
+        # type: () -> int
+        return self._property_impl('size')
+    
+    @size.setter
+    def size(self, new_val):
+        # type: (int) -> None
+        self._size = new_val
+    
+    @property
+    def subFailureDomain(self):
+        # type: () -> str
+        return self._property_impl('subFailureDomain')
+    
+    @subFailureDomain.setter
+    def subFailureDomain(self, new_val):
+        # type: (Optional[str]) -> None
+        self._subFailureDomain = new_val
+    
+    @property
+    def targetSizeRatio(self):
+        # type: () -> float
+        return self._property_impl('targetSizeRatio')
+    
+    @targetSizeRatio.setter
+    def targetSizeRatio(self, new_val):
+        # type: (Optional[float]) -> None
+        self._targetSizeRatio = new_val
+
+
+class Mirror(CrdObject):
+    _properties = [
+        ('disabled', 'disabled', bool, False, False),
+        ('interval', 'interval', str, False, False),
+        ('timeout', 'timeout', str, False, False)
+    ]        
+
+    def __init__(self,
+                 disabled=_omit,  # type: Optional[bool]
+                 interval=_omit,  # type: Optional[str]
+                 timeout=_omit,  # type: Optional[str]
+                 ):
+        super(Mirror, self).__init__(
+            disabled=disabled,
+            interval=interval,
+            timeout=timeout,
+        )
+
+    @property
+    def disabled(self):
+        # type: () -> bool
+        return self._property_impl('disabled')
+    
+    @disabled.setter
+    def disabled(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._disabled = new_val
+    
+    @property
+    def interval(self):
+        # type: () -> str
+        return self._property_impl('interval')
+    
+    @interval.setter
+    def interval(self, new_val):
+        # type: (Optional[str]) -> None
+        self._interval = new_val
+    
+    @property
+    def timeout(self):
+        # type: () -> str
+        return self._property_impl('timeout')
+    
+    @timeout.setter
+    def timeout(self, new_val):
+        # type: (Optional[str]) -> None
+        self._timeout = new_val
+
+
+class StatusCheck(CrdObject):
+    _properties = [
+        ('mirror', 'mirror', 'Mirror', False, True)
+    ]        
+
+    def __init__(self,
+                 mirror=_omit,  # type: Optional[Mirror]
+                 ):
+        super(StatusCheck, self).__init__(
+            mirror=mirror,
+        )
+
+    @property
+    def mirror(self):
+        # type: () -> Optional[Mirror]
+        return self._property_impl('mirror')
+    
+    @mirror.setter
+    def mirror(self, new_val):
+        # type: (Optional[Mirror]) -> None
+        self._mirror = new_val
+
+
+class DataPool(CrdObject):
+    _properties = [
+        ('compressionMode', 'compressionMode', str, False, True),
+        ('crushRoot', 'crushRoot', str, False, True),
+        ('deviceClass', 'deviceClass', str, False, True),
+        ('enableRBDStats', 'enableRBDStats', bool, False, False),
+        ('erasureCoded', 'erasureCoded', 'ErasureCoded', False, False),
+        ('failureDomain', 'failureDomain', str, False, False),
+        ('mirroring', 'mirroring', 'Mirroring', False, False),
+        ('parameters', 'parameters', object, False, True),
+        ('quotas', 'quotas', 'Quotas', False, True),
+        ('replicated', 'replicated', 'Replicated', False, False),
+        ('statusCheck', 'statusCheck', 'StatusCheck', False, False)
+    ]        
+
+    def __init__(self,
+                 compressionMode=_omit,  # type: Optional[str]
+                 crushRoot=_omit,  # type: Optional[str]
+                 deviceClass=_omit,  # type: Optional[str]
+                 enableRBDStats=_omit,  # type: Optional[bool]
+                 erasureCoded=_omit,  # type: Optional[ErasureCoded]
+                 failureDomain=_omit,  # type: Optional[str]
+                 mirroring=_omit,  # type: Optional[Mirroring]
+                 parameters=_omit,  # type: Optional[Any]
+                 quotas=_omit,  # type: Optional[Quotas]
+                 replicated=_omit,  # type: Optional[Replicated]
+                 statusCheck=_omit,  # type: Optional[StatusCheck]
+                 ):
+        super(DataPool, self).__init__(
+            compressionMode=compressionMode,
+            crushRoot=crushRoot,
+            deviceClass=deviceClass,
+            enableRBDStats=enableRBDStats,
+            erasureCoded=erasureCoded,
+            failureDomain=failureDomain,
+            mirroring=mirroring,
+            parameters=parameters,
+            quotas=quotas,
+            replicated=replicated,
+            statusCheck=statusCheck,
+        )
+
+    @property
+    def compressionMode(self):
+        # type: () -> Optional[str]
+        return self._property_impl('compressionMode')
+    
+    @compressionMode.setter
+    def compressionMode(self, new_val):
+        # type: (Optional[str]) -> None
+        self._compressionMode = new_val
+    
+    @property
+    def crushRoot(self):
+        # type: () -> Optional[str]
+        return self._property_impl('crushRoot')
+    
+    @crushRoot.setter
+    def crushRoot(self, new_val):
+        # type: (Optional[str]) -> None
+        self._crushRoot = new_val
+    
+    @property
+    def deviceClass(self):
+        # type: () -> Optional[str]
+        return self._property_impl('deviceClass')
+    
+    @deviceClass.setter
+    def deviceClass(self, new_val):
+        # type: (Optional[str]) -> None
+        self._deviceClass = new_val
+    
+    @property
+    def enableRBDStats(self):
+        # type: () -> bool
+        return self._property_impl('enableRBDStats')
+    
+    @enableRBDStats.setter
+    def enableRBDStats(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._enableRBDStats = new_val
+    
+    @property
+    def erasureCoded(self):
+        # type: () -> ErasureCoded
+        return self._property_impl('erasureCoded')
+    
+    @erasureCoded.setter
+    def erasureCoded(self, new_val):
+        # type: (Optional[ErasureCoded]) -> None
+        self._erasureCoded = new_val
+    
+    @property
+    def failureDomain(self):
+        # type: () -> str
+        return self._property_impl('failureDomain')
+    
+    @failureDomain.setter
+    def failureDomain(self, new_val):
+        # type: (Optional[str]) -> None
+        self._failureDomain = new_val
+    
+    @property
+    def mirroring(self):
+        # type: () -> Mirroring
+        return self._property_impl('mirroring')
+    
+    @mirroring.setter
+    def mirroring(self, new_val):
+        # type: (Optional[Mirroring]) -> None
+        self._mirroring = new_val
+    
+    @property
+    def parameters(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('parameters')
+    
+    @parameters.setter
+    def parameters(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._parameters = new_val
+    
+    @property
+    def quotas(self):
+        # type: () -> Optional[Quotas]
+        return self._property_impl('quotas')
+    
+    @quotas.setter
+    def quotas(self, new_val):
+        # type: (Optional[Quotas]) -> None
+        self._quotas = new_val
+    
+    @property
+    def replicated(self):
+        # type: () -> Replicated
+        return self._property_impl('replicated')
+    
+    @replicated.setter
+    def replicated(self, new_val):
+        # type: (Optional[Replicated]) -> None
+        self._replicated = new_val
+    
+    @property
+    def statusCheck(self):
+        # type: () -> StatusCheck
+        return self._property_impl('statusCheck')
+    
+    @statusCheck.setter
+    def statusCheck(self, new_val):
+        # type: (Optional[StatusCheck]) -> None
+        self._statusCheck = new_val
+
+
+class MetadataPool(CrdObject):
+    _properties = [
+        ('compressionMode', 'compressionMode', str, False, True),
+        ('crushRoot', 'crushRoot', str, False, True),
+        ('deviceClass', 'deviceClass', str, False, True),
+        ('enableRBDStats', 'enableRBDStats', bool, False, False),
+        ('erasureCoded', 'erasureCoded', 'ErasureCoded', False, False),
+        ('failureDomain', 'failureDomain', str, False, False),
+        ('mirroring', 'mirroring', 'Mirroring', False, False),
+        ('parameters', 'parameters', object, False, True),
+        ('quotas', 'quotas', 'Quotas', False, True),
+        ('replicated', 'replicated', 'Replicated', False, False),
+        ('statusCheck', 'statusCheck', 'StatusCheck', False, False)
+    ]        
+
+    def __init__(self,
+                 compressionMode=_omit,  # type: Optional[str]
+                 crushRoot=_omit,  # type: Optional[str]
+                 deviceClass=_omit,  # type: Optional[str]
+                 enableRBDStats=_omit,  # type: Optional[bool]
+                 erasureCoded=_omit,  # type: Optional[ErasureCoded]
+                 failureDomain=_omit,  # type: Optional[str]
+                 mirroring=_omit,  # type: Optional[Mirroring]
+                 parameters=_omit,  # type: Optional[Any]
+                 quotas=_omit,  # type: Optional[Quotas]
+                 replicated=_omit,  # type: Optional[Replicated]
+                 statusCheck=_omit,  # type: Optional[StatusCheck]
+                 ):
+        super(MetadataPool, self).__init__(
+            compressionMode=compressionMode,
+            crushRoot=crushRoot,
+            deviceClass=deviceClass,
+            enableRBDStats=enableRBDStats,
+            erasureCoded=erasureCoded,
+            failureDomain=failureDomain,
+            mirroring=mirroring,
+            parameters=parameters,
+            quotas=quotas,
+            replicated=replicated,
+            statusCheck=statusCheck,
+        )
+
+    @property
+    def compressionMode(self):
+        # type: () -> Optional[str]
+        return self._property_impl('compressionMode')
+    
+    @compressionMode.setter
+    def compressionMode(self, new_val):
+        # type: (Optional[str]) -> None
+        self._compressionMode = new_val
+    
+    @property
+    def crushRoot(self):
+        # type: () -> Optional[str]
+        return self._property_impl('crushRoot')
+    
+    @crushRoot.setter
+    def crushRoot(self, new_val):
+        # type: (Optional[str]) -> None
+        self._crushRoot = new_val
+    
+    @property
+    def deviceClass(self):
+        # type: () -> Optional[str]
+        return self._property_impl('deviceClass')
+    
+    @deviceClass.setter
+    def deviceClass(self, new_val):
+        # type: (Optional[str]) -> None
+        self._deviceClass = new_val
+    
+    @property
+    def enableRBDStats(self):
+        # type: () -> bool
+        return self._property_impl('enableRBDStats')
+    
+    @enableRBDStats.setter
+    def enableRBDStats(self, new_val):
+        # type: (Optional[bool]) -> None
+        self._enableRBDStats = new_val
+    
+    @property
+    def erasureCoded(self):
+        # type: () -> ErasureCoded
+        return self._property_impl('erasureCoded')
+    
+    @erasureCoded.setter
+    def erasureCoded(self, new_val):
+        # type: (Optional[ErasureCoded]) -> None
+        self._erasureCoded = new_val
+    
+    @property
+    def failureDomain(self):
+        # type: () -> str
+        return self._property_impl('failureDomain')
+    
+    @failureDomain.setter
+    def failureDomain(self, new_val):
+        # type: (Optional[str]) -> None
+        self._failureDomain = new_val
+    
+    @property
+    def mirroring(self):
+        # type: () -> Mirroring
+        return self._property_impl('mirroring')
+    
+    @mirroring.setter
+    def mirroring(self, new_val):
+        # type: (Optional[Mirroring]) -> None
+        self._mirroring = new_val
+    
+    @property
+    def parameters(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('parameters')
+    
+    @parameters.setter
+    def parameters(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._parameters = new_val
+    
+    @property
+    def quotas(self):
+        # type: () -> Optional[Quotas]
+        return self._property_impl('quotas')
+    
+    @quotas.setter
+    def quotas(self, new_val):
+        # type: (Optional[Quotas]) -> None
+        self._quotas = new_val
+    
+    @property
+    def replicated(self):
+        # type: () -> Replicated
+        return self._property_impl('replicated')
+    
+    @replicated.setter
+    def replicated(self, new_val):
+        # type: (Optional[Replicated]) -> None
+        self._replicated = new_val
+    
+    @property
+    def statusCheck(self):
+        # type: () -> StatusCheck
+        return self._property_impl('statusCheck')
+    
+    @statusCheck.setter
+    def statusCheck(self, new_val):
+        # type: (Optional[StatusCheck]) -> None
+        self._statusCheck = new_val
+
+
+class Spec(CrdObject):
+    _properties = [
+        ('dataPool', 'dataPool', 'DataPool', True, True),
+        ('metadataPool', 'metadataPool', 'MetadataPool', True, True),
+        ('zoneGroup', 'zoneGroup', str, True, False)
+    ]        
+
+    def __init__(self,
+                 dataPool,  # type: Optional[DataPool]
+                 metadataPool,  # type: Optional[MetadataPool]
+                 zoneGroup,  # type: str
+                 ):
+        super(Spec, self).__init__(
+            dataPool=dataPool,
+            metadataPool=metadataPool,
+            zoneGroup=zoneGroup,
+        )
+
+    @property
+    def dataPool(self):
+        # type: () -> Optional[DataPool]
+        return self._property_impl('dataPool')
+    
+    @dataPool.setter
+    def dataPool(self, new_val):
+        # type: (Optional[DataPool]) -> None
+        self._dataPool = new_val
+    
+    @property
+    def metadataPool(self):
+        # type: () -> Optional[MetadataPool]
+        return self._property_impl('metadataPool')
+    
+    @metadataPool.setter
+    def metadataPool(self, new_val):
+        # type: (Optional[MetadataPool]) -> None
+        self._metadataPool = new_val
+    
+    @property
+    def zoneGroup(self):
+        # type: () -> str
+        return self._property_impl('zoneGroup')
+    
+    @zoneGroup.setter
+    def zoneGroup(self, new_val):
+        # type: (str) -> None
+        self._zoneGroup = new_val
+
+
+class Status(CrdObject):
+    _properties = [
+        ('phase', 'phase', str, False, False)
+    ]        
+
+    def __init__(self,
+                 phase=_omit,  # type: Optional[str]
+                 ):
+        super(Status, self).__init__(
+            phase=phase,
+        )
+
+    @property
+    def phase(self):
+        # type: () -> str
+        return self._property_impl('phase')
+    
+    @phase.setter
+    def phase(self, new_val):
+        # type: (Optional[str]) -> None
+        self._phase = new_val
+
+
+class CephObjectZone(CrdClass):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('kind', 'kind', str, False, False),
+        ('metadata', 'metadata', object, False, False),
+        ('spec', 'spec', 'Spec', True, False),
+        ('status', 'status', 'Status', False, False)
+    ]        
+
+    def __init__(self,
+                 spec,  # type: Spec
+                 apiVersion=_omit,  # type: Optional[str]
+                 kind=_omit,  # type: Optional[str]
+                 metadata=_omit,  # type: Optional[Any]
+                 status=_omit,  # type: Optional[Status]
+                 ):
+        super(CephObjectZone, self).__init__(
+            spec=spec,
+            apiVersion=apiVersion,
+            kind=kind,
+            metadata=metadata,
+            status=status,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Any
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._metadata = new_val
+    
+    @property
+    def spec(self):
+        # type: () -> Spec
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Spec) -> None
+        self._spec = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Status
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Status]) -> None
+        self._status = new_val
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectzonegroup.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectzonegroup.py
new file mode 100644
index 000000000..d535a1b7a
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectzonegroup.py
@@ -0,0 +1,131 @@
+"""
+This file is automatically generated.
+Do not modify.
+"""
+
+try:
+    from typing import Any, Optional, Union, List
+except ImportError:
+    pass
+
+from .._helper import _omit, CrdObject, CrdObjectList, CrdClass
+
+class Spec(CrdObject):
+    _properties = [
+        ('realm', 'realm', str, True, False)
+    ]        
+
+    def __init__(self,
+                 realm,  # type: str
+                 ):
+        super(Spec, self).__init__(
+            realm=realm,
+        )
+
+    @property
+    def realm(self):
+        # type: () -> str
+        return self._property_impl('realm')
+    
+    @realm.setter
+    def realm(self, new_val):
+        # type: (str) -> None
+        self._realm = new_val
+
+
+class Status(CrdObject):
+    _properties = [
+        ('phase', 'phase', str, False, False)
+    ]        
+
+    def __init__(self,
+                 phase=_omit,  # type: Optional[str]
+                 ):
+        super(Status, self).__init__(
+            phase=phase,
+        )
+
+    @property
+    def phase(self):
+        # type: () -> str
+        return self._property_impl('phase')
+    
+    @phase.setter
+    def phase(self, new_val):
+        # type: (Optional[str]) -> None
+        self._phase = new_val
+
+
+class CephObjectZoneGroup(CrdClass):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('kind', 'kind', str, False, False),
+        ('metadata', 'metadata', object, False, False),
+        ('spec', 'spec', 'Spec', True, False),
+        ('status', 'status', 'Status', False, False)
+    ]        
+
+    def __init__(self,
+                 spec,  # type: Spec
+                 apiVersion=_omit,  # type: Optional[str]
+                 kind=_omit,  # type: Optional[str]
+                 metadata=_omit,  # type: Optional[Any]
+                 status=_omit,  # type: Optional[Status]
+                 ):
+        super(CephObjectZoneGroup, self).__init__(
+            spec=spec,
+            apiVersion=apiVersion,
+            kind=kind,
+            metadata=metadata,
+            status=status,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Any
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._metadata = new_val
+    
+    @property
+    def spec(self):
+        # type: () -> Spec
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Spec) -> None
+        self._spec = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Status
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Status]) -> None
+        self._status = new_val
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephrbdmirror.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephrbdmirror.py
new file mode 100644
index 000000000..4d121377f
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephrbdmirror.py
@@ -0,0 +1,1066 @@
+"""
+This file is automatically generated.
+Do not modify.
+"""
+
+try:
+    from typing import Any, Optional, Union, List
+except ImportError:
+    pass
+
+from .._helper import _omit, CrdObject, CrdObjectList, CrdClass
+
+class SecretNamesList(CrdObjectList):
+    _items_type = str
+
+
+class Peers(CrdObject):
+    _properties = [
+        ('secretNames', 'secretNames', 'SecretNamesList', False, False)
+    ]        
+
+    def __init__(self,
+                 secretNames=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(Peers, self).__init__(
+            secretNames=secretNames,
+        )
+
+    @property
+    def secretNames(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('secretNames')
+    
+    @secretNames.setter
+    def secretNames(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._secretNames = new_val
+
+
+class ValuesList(CrdObjectList):
+    _items_type = str
+
+
+class MatchExpressionsItem(CrdObject):
+    _properties = [
+        ('key', 'key', str, True, False),
+        ('operator', 'operator', str, True, False),
+        ('values', 'values', 'ValuesList', False, False)
+    ]        
+
+    def __init__(self,
+                 key,  # type: str
+                 operator,  # type: str
+                 values=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(MatchExpressionsItem, self).__init__(
+            key=key,
+            operator=operator,
+            values=values,
+        )
+
+    @property
+    def key(self):
+        # type: () -> str
+        return self._property_impl('key')
+    
+    @key.setter
+    def key(self, new_val):
+        # type: (str) -> None
+        self._key = new_val
+    
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._property_impl('operator')
+    
+    @operator.setter
+    def operator(self, new_val):
+        # type: (str) -> None
+        self._operator = new_val
+    
+    @property
+    def values(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('values')
+    
+    @values.setter
+    def values(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._values = new_val
+
+
+class MatchExpressionsList(CrdObjectList):
+    _items_type = MatchExpressionsItem
+
+
+class MatchFieldsItem(CrdObject):
+    _properties = [
+        ('key', 'key', str, True, False),
+        ('operator', 'operator', str, True, False),
+        ('values', 'values', 'ValuesList', False, False)
+    ]        
+
+    def __init__(self,
+                 key,  # type: str
+                 operator,  # type: str
+                 values=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(MatchFieldsItem, self).__init__(
+            key=key,
+            operator=operator,
+            values=values,
+        )
+
+    @property
+    def key(self):
+        # type: () -> str
+        return self._property_impl('key')
+    
+    @key.setter
+    def key(self, new_val):
+        # type: (str) -> None
+        self._key = new_val
+    
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._property_impl('operator')
+    
+    @operator.setter
+    def operator(self, new_val):
+        # type: (str) -> None
+        self._operator = new_val
+    
+    @property
+    def values(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('values')
+    
+    @values.setter
+    def values(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._values = new_val
+
+
+class MatchFieldsList(CrdObjectList):
+    _items_type = MatchFieldsItem
+
+
+class Preference(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchFields', 'matchFields', 'MatchFieldsList', False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchFields=_omit,  # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]]
+                 ):
+        super(Preference, self).__init__(
+            matchExpressions=matchExpressions,
+            matchFields=matchFields,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchFields(self):
+        # type: () -> Union[List[MatchFieldsItem], CrdObjectList]
+        return self._property_impl('matchFields')
+    
+    @matchFields.setter
+    def matchFields(self, new_val):
+        # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None
+        self._matchFields = new_val
+
+
+class PreferredDuringSchedulingIgnoredDuringExecutionItem(CrdObject):
+    _properties = [
+        ('podAffinityTerm', 'podAffinityTerm', 'PodAffinityTerm', False, False),
+        ('weight', 'weight', int, False, False),
+        ('preference', 'preference', 'Preference', False, False)
+    ]        
+
+    def __init__(self,
+                 podAffinityTerm=_omit,  # type: Optional[PodAffinityTerm]
+                 weight=_omit,  # type: Optional[int]
+                 preference=_omit,  # type: Optional[Preference]
+                 ):
+        super(PreferredDuringSchedulingIgnoredDuringExecutionItem, self).__init__(
+            podAffinityTerm=podAffinityTerm,
+            weight=weight,
+            preference=preference,
+        )
+
+    @property
+    def podAffinityTerm(self):
+        # type: () -> PodAffinityTerm
+        return self._property_impl('podAffinityTerm')
+    
+    @podAffinityTerm.setter
+    def podAffinityTerm(self, new_val):
+        # type: (Optional[PodAffinityTerm]) -> None
+        self._podAffinityTerm = new_val
+    
+    @property
+    def weight(self):
+        # type: () -> int
+        return self._property_impl('weight')
+    
+    @weight.setter
+    def weight(self, new_val):
+        # type: (Optional[int]) -> None
+        self._weight = new_val
+    
+    @property
+    def preference(self):
+        # type: () -> Preference
+        return self._property_impl('preference')
+    
+    @preference.setter
+    def preference(self, new_val):
+        # type: (Optional[Preference]) -> None
+        self._preference = new_val
+
+
+class PreferredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList):
+    _items_type = PreferredDuringSchedulingIgnoredDuringExecutionItem
+
+
+class NodeSelectorTermsItem(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchFields', 'matchFields', 'MatchFieldsList', False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchFields=_omit,  # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]]
+                 ):
+        super(NodeSelectorTermsItem, self).__init__(
+            matchExpressions=matchExpressions,
+            matchFields=matchFields,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchFields(self):
+        # type: () -> Union[List[MatchFieldsItem], CrdObjectList]
+        return self._property_impl('matchFields')
+    
+    @matchFields.setter
+    def matchFields(self, new_val):
+        # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None
+        self._matchFields = new_val
+
+
+class NodeSelectorTermsList(CrdObjectList):
+    _items_type = NodeSelectorTermsItem
+
+
+class RequiredDuringSchedulingIgnoredDuringExecution(CrdObject):
+    _properties = [
+        ('nodeSelectorTerms', 'nodeSelectorTerms', 'NodeSelectorTermsList', True, False)
+    ]        
+
+    def __init__(self,
+                 nodeSelectorTerms,  # type: Union[List[NodeSelectorTermsItem], CrdObjectList]
+                 ):
+        super(RequiredDuringSchedulingIgnoredDuringExecution, self).__init__(
+            nodeSelectorTerms=nodeSelectorTerms,
+        )
+
+    @property
+    def nodeSelectorTerms(self):
+        # type: () -> Union[List[NodeSelectorTermsItem], CrdObjectList]
+        return self._property_impl('nodeSelectorTerms')
+    
+    @nodeSelectorTerms.setter
+    def nodeSelectorTerms(self, new_val):
+        # type: (Union[List[NodeSelectorTermsItem], CrdObjectList]) -> None
+        self._nodeSelectorTerms = new_val
+
+
+class NodeAffinity(CrdObject):
+    _properties = [
+        ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False),
+        ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecution', False, False)
+    ]        
+
+    def __init__(self,
+                 preferredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 requiredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[RequiredDuringSchedulingIgnoredDuringExecution]
+                 ):
+        super(NodeAffinity, self).__init__(
+            preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution,
+            requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution,
+        )
+
+    @property
+    def preferredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution')
+    
+    @preferredDuringSchedulingIgnoredDuringExecution.setter
+    def preferredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._preferredDuringSchedulingIgnoredDuringExecution = new_val
+    
+    @property
+    def requiredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> RequiredDuringSchedulingIgnoredDuringExecution
+        return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution')
+    
+    @requiredDuringSchedulingIgnoredDuringExecution.setter
+    def requiredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[RequiredDuringSchedulingIgnoredDuringExecution]) -> None
+        self._requiredDuringSchedulingIgnoredDuringExecution = new_val
+
+
+class LabelSelector(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchLabels', 'matchLabels', object, False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchLabels=_omit,  # type: Optional[Any]
+                 ):
+        super(LabelSelector, self).__init__(
+            matchExpressions=matchExpressions,
+            matchLabels=matchLabels,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchLabels(self):
+        # type: () -> Any
+        return self._property_impl('matchLabels')
+    
+    @matchLabels.setter
+    def matchLabels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._matchLabels = new_val
+
+
+class NamespaceSelector(CrdObject):
+    _properties = [
+        ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False),
+        ('matchLabels', 'matchLabels', object, False, False)
+    ]        
+
+    def __init__(self,
+                 matchExpressions=_omit,  # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]]
+                 matchLabels=_omit,  # type: Optional[Any]
+                 ):
+        super(NamespaceSelector, self).__init__(
+            matchExpressions=matchExpressions,
+            matchLabels=matchLabels,
+        )
+
+    @property
+    def matchExpressions(self):
+        # type: () -> Union[List[MatchExpressionsItem], CrdObjectList]
+        return self._property_impl('matchExpressions')
+    
+    @matchExpressions.setter
+    def matchExpressions(self, new_val):
+        # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None
+        self._matchExpressions = new_val
+    
+    @property
+    def matchLabels(self):
+        # type: () -> Any
+        return self._property_impl('matchLabels')
+    
+    @matchLabels.setter
+    def matchLabels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._matchLabels = new_val
+
+
+class NamespacesList(CrdObjectList):
+    _items_type = str
+
+
+class PodAffinityTerm(CrdObject):
+    _properties = [
+        ('labelSelector', 'labelSelector', 'LabelSelector', False, False),
+        ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False),
+        ('namespaces', 'namespaces', 'NamespacesList', False, False),
+        ('topologyKey', 'topologyKey', str, True, False)
+    ]        
+
+    def __init__(self,
+                 topologyKey,  # type: str
+                 labelSelector=_omit,  # type: Optional[LabelSelector]
+                 namespaceSelector=_omit,  # type: Optional[NamespaceSelector]
+                 namespaces=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(PodAffinityTerm, self).__init__(
+            topologyKey=topologyKey,
+            labelSelector=labelSelector,
+            namespaceSelector=namespaceSelector,
+            namespaces=namespaces,
+        )
+
+    @property
+    def labelSelector(self):
+        # type: () -> LabelSelector
+        return self._property_impl('labelSelector')
+    
+    @labelSelector.setter
+    def labelSelector(self, new_val):
+        # type: (Optional[LabelSelector]) -> None
+        self._labelSelector = new_val
+    
+    @property
+    def namespaceSelector(self):
+        # type: () -> NamespaceSelector
+        return self._property_impl('namespaceSelector')
+    
+    @namespaceSelector.setter
+    def namespaceSelector(self, new_val):
+        # type: (Optional[NamespaceSelector]) -> None
+        self._namespaceSelector = new_val
+    
+    @property
+    def namespaces(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('namespaces')
+    
+    @namespaces.setter
+    def namespaces(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._namespaces = new_val
+    
+    @property
+    def topologyKey(self):
+        # type: () -> str
+        return self._property_impl('topologyKey')
+    
+    @topologyKey.setter
+    def topologyKey(self, new_val):
+        # type: (str) -> None
+        self._topologyKey = new_val
+
+
+class RequiredDuringSchedulingIgnoredDuringExecutionItem(CrdObject):
+    _properties = [
+        ('labelSelector', 'labelSelector', 'LabelSelector', False, False),
+        ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False),
+        ('namespaces', 'namespaces', 'NamespacesList', False, False),
+        ('topologyKey', 'topologyKey', str, True, False)
+    ]        
+
+    def __init__(self,
+                 topologyKey,  # type: str
+                 labelSelector=_omit,  # type: Optional[LabelSelector]
+                 namespaceSelector=_omit,  # type: Optional[NamespaceSelector]
+                 namespaces=_omit,  # type: Optional[Union[List[str], CrdObjectList]]
+                 ):
+        super(RequiredDuringSchedulingIgnoredDuringExecutionItem, self).__init__(
+            topologyKey=topologyKey,
+            labelSelector=labelSelector,
+            namespaceSelector=namespaceSelector,
+            namespaces=namespaces,
+        )
+
+    @property
+    def labelSelector(self):
+        # type: () -> LabelSelector
+        return self._property_impl('labelSelector')
+    
+    @labelSelector.setter
+    def labelSelector(self, new_val):
+        # type: (Optional[LabelSelector]) -> None
+        self._labelSelector = new_val
+    
+    @property
+    def namespaceSelector(self):
+        # type: () -> NamespaceSelector
+        return self._property_impl('namespaceSelector')
+    
+    @namespaceSelector.setter
+    def namespaceSelector(self, new_val):
+        # type: (Optional[NamespaceSelector]) -> None
+        self._namespaceSelector = new_val
+    
+    @property
+    def namespaces(self):
+        # type: () -> Union[List[str], CrdObjectList]
+        return self._property_impl('namespaces')
+    
+    @namespaces.setter
+    def namespaces(self, new_val):
+        # type: (Optional[Union[List[str], CrdObjectList]]) -> None
+        self._namespaces = new_val
+    
+    @property
+    def topologyKey(self):
+        # type: () -> str
+        return self._property_impl('topologyKey')
+    
+    @topologyKey.setter
+    def topologyKey(self, new_val):
+        # type: (str) -> None
+        self._topologyKey = new_val
+
+
+class RequiredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList):
+    _items_type = RequiredDuringSchedulingIgnoredDuringExecutionItem
+
+
+class PodAffinity(CrdObject):
+    _properties = [
+        ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False),
+        ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False)
+    ]        
+
+    def __init__(self,
+                 preferredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 requiredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 ):
+        super(PodAffinity, self).__init__(
+            preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution,
+            requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution,
+        )
+
+    @property
+    def preferredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution')
+    
+    @preferredDuringSchedulingIgnoredDuringExecution.setter
+    def preferredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._preferredDuringSchedulingIgnoredDuringExecution = new_val
+    
+    @property
+    def requiredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution')
+    
+    @requiredDuringSchedulingIgnoredDuringExecution.setter
+    def requiredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._requiredDuringSchedulingIgnoredDuringExecution = new_val
+
+
+class PodAntiAffinity(CrdObject):
+    _properties = [
+        ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False),
+        ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False)
+    ]        
+
+    def __init__(self,
+                 preferredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 requiredDuringSchedulingIgnoredDuringExecution=_omit,  # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]
+                 ):
+        super(PodAntiAffinity, self).__init__(
+            preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution,
+            requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution,
+        )
+
+    @property
+    def preferredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution')
+    
+    @preferredDuringSchedulingIgnoredDuringExecution.setter
+    def preferredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._preferredDuringSchedulingIgnoredDuringExecution = new_val
+    
+    @property
+    def requiredDuringSchedulingIgnoredDuringExecution(self):
+        # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]
+        return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution')
+    
+    @requiredDuringSchedulingIgnoredDuringExecution.setter
+    def requiredDuringSchedulingIgnoredDuringExecution(self, new_val):
+        # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None
+        self._requiredDuringSchedulingIgnoredDuringExecution = new_val
+
+
+class TolerationsItem(CrdObject):
+    _properties = [
+        ('effect', 'effect', str, False, False),
+        ('key', 'key', str, False, False),
+        ('operator', 'operator', str, False, False),
+        ('tolerationSeconds', 'tolerationSeconds', int, False, False),
+        ('value', 'value', str, False, False)
+    ]        
+
+    def __init__(self,
+                 effect=_omit,  # type: Optional[str]
+                 key=_omit,  # type: Optional[str]
+                 operator=_omit,  # type: Optional[str]
+                 tolerationSeconds=_omit,  # type: Optional[int]
+                 value=_omit,  # type: Optional[str]
+                 ):
+        super(TolerationsItem, self).__init__(
+            effect=effect,
+            key=key,
+            operator=operator,
+            tolerationSeconds=tolerationSeconds,
+            value=value,
+        )
+
+    @property
+    def effect(self):
+        # type: () -> str
+        return self._property_impl('effect')
+    
+    @effect.setter
+    def effect(self, new_val):
+        # type: (Optional[str]) -> None
+        self._effect = new_val
+    
+    @property
+    def key(self):
+        # type: () -> str
+        return self._property_impl('key')
+    
+    @key.setter
+    def key(self, new_val):
+        # type: (Optional[str]) -> None
+        self._key = new_val
+    
+    @property
+    def operator(self):
+        # type: () -> str
+        return self._property_impl('operator')
+    
+    @operator.setter
+    def operator(self, new_val):
+        # type: (Optional[str]) -> None
+        self._operator = new_val
+    
+    @property
+    def tolerationSeconds(self):
+        # type: () -> int
+        return self._property_impl('tolerationSeconds')
+    
+    @tolerationSeconds.setter
+    def tolerationSeconds(self, new_val):
+        # type: (Optional[int]) -> None
+        self._tolerationSeconds = new_val
+    
+    @property
+    def value(self):
+        # type: () -> str
+        return self._property_impl('value')
+    
+    @value.setter
+    def value(self, new_val):
+        # type: (Optional[str]) -> None
+        self._value = new_val
+
+
+class TolerationsList(CrdObjectList):
+    _items_type = TolerationsItem
+
+
+class TopologySpreadConstraintsItem(CrdObject):
+    _properties = [
+        ('labelSelector', 'labelSelector', 'LabelSelector', False, False),
+        ('maxSkew', 'maxSkew', int, True, False),
+        ('topologyKey', 'topologyKey', str, True, False),
+        ('whenUnsatisfiable', 'whenUnsatisfiable', str, True, False)
+    ]        
+
+    def __init__(self,
+                 maxSkew,  # type: int
+                 topologyKey,  # type: str
+                 whenUnsatisfiable,  # type: str
+                 labelSelector=_omit,  # type: Optional[LabelSelector]
+                 ):
+        super(TopologySpreadConstraintsItem, self).__init__(
+            maxSkew=maxSkew,
+            topologyKey=topologyKey,
+            whenUnsatisfiable=whenUnsatisfiable,
+            labelSelector=labelSelector,
+        )
+
+    @property
+    def labelSelector(self):
+        # type: () -> LabelSelector
+        return self._property_impl('labelSelector')
+    
+    @labelSelector.setter
+    def labelSelector(self, new_val):
+        # type: (Optional[LabelSelector]) -> None
+        self._labelSelector = new_val
+    
+    @property
+    def maxSkew(self):
+        # type: () -> int
+        return self._property_impl('maxSkew')
+    
+    @maxSkew.setter
+    def maxSkew(self, new_val):
+        # type: (int) -> None
+        self._maxSkew = new_val
+    
+    @property
+    def topologyKey(self):
+        # type: () -> str
+        return self._property_impl('topologyKey')
+    
+    @topologyKey.setter
+    def topologyKey(self, new_val):
+        # type: (str) -> None
+        self._topologyKey = new_val
+    
+    @property
+    def whenUnsatisfiable(self):
+        # type: () -> str
+        return self._property_impl('whenUnsatisfiable')
+    
+    @whenUnsatisfiable.setter
+    def whenUnsatisfiable(self, new_val):
+        # type: (str) -> None
+        self._whenUnsatisfiable = new_val
+
+
+class TopologySpreadConstraintsList(CrdObjectList):
+    _items_type = TopologySpreadConstraintsItem
+
+
+class Placement(CrdObject):
+    _properties = [
+        ('nodeAffinity', 'nodeAffinity', 'NodeAffinity', False, False),
+        ('podAffinity', 'podAffinity', 'PodAffinity', False, False),
+        ('podAntiAffinity', 'podAntiAffinity', 'PodAntiAffinity', False, False),
+        ('tolerations', 'tolerations', 'TolerationsList', False, False),
+        ('topologySpreadConstraints', 'topologySpreadConstraints', 'TopologySpreadConstraintsList', False, False)
+    ]        
+
+    def __init__(self,
+                 nodeAffinity=_omit,  # type: Optional[NodeAffinity]
+                 podAffinity=_omit,  # type: Optional[PodAffinity]
+                 podAntiAffinity=_omit,  # type: Optional[PodAntiAffinity]
+                 tolerations=_omit,  # type: Optional[Union[List[TolerationsItem], CrdObjectList]]
+                 topologySpreadConstraints=_omit,  # type: Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]
+                 ):
+        super(Placement, self).__init__(
+            nodeAffinity=nodeAffinity,
+            podAffinity=podAffinity,
+            podAntiAffinity=podAntiAffinity,
+            tolerations=tolerations,
+            topologySpreadConstraints=topologySpreadConstraints,
+        )
+
+    @property
+    def nodeAffinity(self):
+        # type: () -> NodeAffinity
+        return self._property_impl('nodeAffinity')
+    
+    @nodeAffinity.setter
+    def nodeAffinity(self, new_val):
+        # type: (Optional[NodeAffinity]) -> None
+        self._nodeAffinity = new_val
+    
+    @property
+    def podAffinity(self):
+        # type: () -> PodAffinity
+        return self._property_impl('podAffinity')
+    
+    @podAffinity.setter
+    def podAffinity(self, new_val):
+        # type: (Optional[PodAffinity]) -> None
+        self._podAffinity = new_val
+    
+    @property
+    def podAntiAffinity(self):
+        # type: () -> PodAntiAffinity
+        return self._property_impl('podAntiAffinity')
+    
+    @podAntiAffinity.setter
+    def podAntiAffinity(self, new_val):
+        # type: (Optional[PodAntiAffinity]) -> None
+        self._podAntiAffinity = new_val
+    
+    @property
+    def tolerations(self):
+        # type: () -> Union[List[TolerationsItem], CrdObjectList]
+        return self._property_impl('tolerations')
+    
+    @tolerations.setter
+    def tolerations(self, new_val):
+        # type: (Optional[Union[List[TolerationsItem], CrdObjectList]]) -> None
+        self._tolerations = new_val
+    
+    @property
+    def topologySpreadConstraints(self):
+        # type: () -> Union[List[TopologySpreadConstraintsItem], CrdObjectList]
+        return self._property_impl('topologySpreadConstraints')
+    
+    @topologySpreadConstraints.setter
+    def topologySpreadConstraints(self, new_val):
+        # type: (Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]) -> None
+        self._topologySpreadConstraints = new_val
+
+
+class Resources(CrdObject):
+    _properties = [
+        ('limits', 'limits', object, False, False),
+        ('requests', 'requests', object, False, False)
+    ]        
+
+    def __init__(self,
+                 limits=_omit,  # type: Optional[Any]
+                 requests=_omit,  # type: Optional[Any]
+                 ):
+        super(Resources, self).__init__(
+            limits=limits,
+            requests=requests,
+        )
+
+    @property
+    def limits(self):
+        # type: () -> Any
+        return self._property_impl('limits')
+    
+    @limits.setter
+    def limits(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._limits = new_val
+    
+    @property
+    def requests(self):
+        # type: () -> Any
+        return self._property_impl('requests')
+    
+    @requests.setter
+    def requests(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._requests = new_val
+
+
+class Spec(CrdObject):
+    _properties = [
+        ('annotations', 'annotations', object, False, True),
+        ('count', 'count', int, True, False),
+        ('labels', 'labels', object, False, True),
+        ('peers', 'peers', 'Peers', False, True),
+        ('placement', 'placement', 'Placement', False, True),
+        ('priorityClassName', 'priorityClassName', str, False, False),
+        ('resources', 'resources', 'Resources', False, True)
+    ]        
+
+    def __init__(self,
+                 count,  # type: int
+                 annotations=_omit,  # type: Optional[Any]
+                 labels=_omit,  # type: Optional[Any]
+                 peers=_omit,  # type: Optional[Peers]
+                 placement=_omit,  # type: Optional[Placement]
+                 priorityClassName=_omit,  # type: Optional[str]
+                 resources=_omit,  # type: Optional[Resources]
+                 ):
+        super(Spec, self).__init__(
+            count=count,
+            annotations=annotations,
+            labels=labels,
+            peers=peers,
+            placement=placement,
+            priorityClassName=priorityClassName,
+            resources=resources,
+        )
+
+    @property
+    def annotations(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('annotations')
+    
+    @annotations.setter
+    def annotations(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._annotations = new_val
+    
+    @property
+    def count(self):
+        # type: () -> int
+        return self._property_impl('count')
+    
+    @count.setter
+    def count(self, new_val):
+        # type: (int) -> None
+        self._count = new_val
+    
+    @property
+    def labels(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('labels')
+    
+    @labels.setter
+    def labels(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._labels = new_val
+    
+    @property
+    def peers(self):
+        # type: () -> Optional[Peers]
+        return self._property_impl('peers')
+    
+    @peers.setter
+    def peers(self, new_val):
+        # type: (Optional[Peers]) -> None
+        self._peers = new_val
+    
+    @property
+    def placement(self):
+        # type: () -> Optional[Placement]
+        return self._property_impl('placement')
+    
+    @placement.setter
+    def placement(self, new_val):
+        # type: (Optional[Placement]) -> None
+        self._placement = new_val
+    
+    @property
+    def priorityClassName(self):
+        # type: () -> str
+        return self._property_impl('priorityClassName')
+    
+    @priorityClassName.setter
+    def priorityClassName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._priorityClassName = new_val
+    
+    @property
+    def resources(self):
+        # type: () -> Optional[Resources]
+        return self._property_impl('resources')
+    
+    @resources.setter
+    def resources(self, new_val):
+        # type: (Optional[Resources]) -> None
+        self._resources = new_val
+
+
+class Status(CrdObject):
+    _properties = [
+        ('phase', 'phase', str, False, False)
+    ]        
+
+    def __init__(self,
+                 phase=_omit,  # type: Optional[str]
+                 ):
+        super(Status, self).__init__(
+            phase=phase,
+        )
+
+    @property
+    def phase(self):
+        # type: () -> str
+        return self._property_impl('phase')
+    
+    @phase.setter
+    def phase(self, new_val):
+        # type: (Optional[str]) -> None
+        self._phase = new_val
+
+
+class CephRBDMirror(CrdClass):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('kind', 'kind', str, False, False),
+        ('metadata', 'metadata', object, False, False),
+        ('spec', 'spec', 'Spec', True, False),
+        ('status', 'status', 'Status', False, False)
+    ]        
+
+    def __init__(self,
+                 spec,  # type: Spec
+                 apiVersion=_omit,  # type: Optional[str]
+                 kind=_omit,  # type: Optional[str]
+                 metadata=_omit,  # type: Optional[Any]
+                 status=_omit,  # type: Optional[Status]
+                 ):
+        super(CephRBDMirror, self).__init__(
+            spec=spec,
+            apiVersion=apiVersion,
+            kind=kind,
+            metadata=metadata,
+            status=status,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Any
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._metadata = new_val
+    
+    @property
+    def spec(self):
+        # type: () -> Spec
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Spec) -> None
+        self._spec = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Status
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Status]) -> None
+        self._status = new_val
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/objectbucket.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/objectbucket.py
new file mode 100644
index 000000000..7d4158a47
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/objectbucket.py
@@ -0,0 +1,252 @@
+"""
+This file is automatically generated.
+Do not modify.
+"""
+
+try:
+    from typing import Any, Optional, Union, List
+except ImportError:
+    pass
+
+from .._helper import _omit, CrdObject, CrdObjectList, CrdClass
+
+class Endpoint(CrdObject):
+    _properties = [
+        ('bucketHost', 'bucketHost', str, False, False),
+        ('bucketPort', 'bucketPort', int, False, False),
+        ('bucketName', 'bucketName', str, False, False),
+        ('region', 'region', str, False, False),
+        ('subRegion', 'subRegion', str, False, False),
+        ('additionalConfig', 'additionalConfig', object, False, True)
+    ]        
+
+    def __init__(self,
+                 bucketHost=_omit,  # type: Optional[str]
+                 bucketPort=_omit,  # type: Optional[int]
+                 bucketName=_omit,  # type: Optional[str]
+                 region=_omit,  # type: Optional[str]
+                 subRegion=_omit,  # type: Optional[str]
+                 additionalConfig=_omit,  # type: Optional[Any]
+                 ):
+        super(Endpoint, self).__init__(
+            bucketHost=bucketHost,
+            bucketPort=bucketPort,
+            bucketName=bucketName,
+            region=region,
+            subRegion=subRegion,
+            additionalConfig=additionalConfig,
+        )
+
+    @property
+    def bucketHost(self):
+        # type: () -> str
+        return self._property_impl('bucketHost')
+    
+    @bucketHost.setter
+    def bucketHost(self, new_val):
+        # type: (Optional[str]) -> None
+        self._bucketHost = new_val
+    
+    @property
+    def bucketPort(self):
+        # type: () -> int
+        return self._property_impl('bucketPort')
+    
+    @bucketPort.setter
+    def bucketPort(self, new_val):
+        # type: (Optional[int]) -> None
+        self._bucketPort = new_val
+    
+    @property
+    def bucketName(self):
+        # type: () -> str
+        return self._property_impl('bucketName')
+    
+    @bucketName.setter
+    def bucketName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._bucketName = new_val
+    
+    @property
+    def region(self):
+        # type: () -> str
+        return self._property_impl('region')
+    
+    @region.setter
+    def region(self, new_val):
+        # type: (Optional[str]) -> None
+        self._region = new_val
+    
+    @property
+    def subRegion(self):
+        # type: () -> str
+        return self._property_impl('subRegion')
+    
+    @subRegion.setter
+    def subRegion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._subRegion = new_val
+    
+    @property
+    def additionalConfig(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('additionalConfig')
+    
+    @additionalConfig.setter
+    def additionalConfig(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._additionalConfig = new_val
+
+
+class AuthenticationList(CrdObjectList):
+    _items_type = None
+
+
+class Spec(CrdObject):
+    _properties = [
+        ('storageClassName', 'storageClassName', str, False, False),
+        ('endpoint', 'endpoint', 'Endpoint', False, True),
+        ('authentication', 'authentication', 'AuthenticationList', False, True),
+        ('additionalState', 'additionalState', object, False, True),
+        ('reclaimPolicy', 'reclaimPolicy', str, False, False),
+        ('claimRef', 'claimRef', object, False, True)
+    ]        
+
+    def __init__(self,
+                 storageClassName=_omit,  # type: Optional[str]
+                 endpoint=_omit,  # type: Optional[Endpoint]
+                 authentication=_omit,  # type: Optional[Union[List[Any], CrdObjectList]]
+                 additionalState=_omit,  # type: Optional[Any]
+                 reclaimPolicy=_omit,  # type: Optional[str]
+                 claimRef=_omit,  # type: Optional[Any]
+                 ):
+        super(Spec, self).__init__(
+            storageClassName=storageClassName,
+            endpoint=endpoint,
+            authentication=authentication,
+            additionalState=additionalState,
+            reclaimPolicy=reclaimPolicy,
+            claimRef=claimRef,
+        )
+
+    @property
+    def storageClassName(self):
+        # type: () -> str
+        return self._property_impl('storageClassName')
+    
+    @storageClassName.setter
+    def storageClassName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._storageClassName = new_val
+    
+    @property
+    def endpoint(self):
+        # type: () -> Optional[Endpoint]
+        return self._property_impl('endpoint')
+    
+    @endpoint.setter
+    def endpoint(self, new_val):
+        # type: (Optional[Endpoint]) -> None
+        self._endpoint = new_val
+    
+    @property
+    def authentication(self):
+        # type: () -> Optional[Union[List[Any], CrdObjectList]]
+        return self._property_impl('authentication')
+    
+    @authentication.setter
+    def authentication(self, new_val):
+        # type: (Optional[Union[List[Any], CrdObjectList]]) -> None
+        self._authentication = new_val
+    
+    @property
+    def additionalState(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('additionalState')
+    
+    @additionalState.setter
+    def additionalState(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._additionalState = new_val
+    
+    @property
+    def reclaimPolicy(self):
+        # type: () -> str
+        return self._property_impl('reclaimPolicy')
+    
+    @reclaimPolicy.setter
+    def reclaimPolicy(self, new_val):
+        # type: (Optional[str]) -> None
+        self._reclaimPolicy = new_val
+    
+    @property
+    def claimRef(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('claimRef')
+    
+    @claimRef.setter
+    def claimRef(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._claimRef = new_val
+
+
+class ObjectBucket(CrdClass):
+    _properties = [
+        ('spec', 'spec', 'Spec', True, False),
+        ('status', 'status', object, False, False),
+        ('apiVersion', 'apiVersion', str, True, False),
+        ('metadata', 'metadata', object, True, False)
+    ]        
+
+    def __init__(self,
+                 spec,  # type: Spec
+                 apiVersion,  # type: str
+                 metadata,  # type: Any
+                 status=_omit,  # type: Optional[Any]
+                 ):
+        super(ObjectBucket, self).__init__(
+            spec=spec,
+            apiVersion=apiVersion,
+            metadata=metadata,
+            status=status,
+        )
+
+    @property
+    def spec(self):
+        # type: () -> Spec
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Spec) -> None
+        self._spec = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Any
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._status = new_val
+    
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (str) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Any
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Any) -> None
+        self._metadata = new_val
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/objectbucketclaim.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/objectbucketclaim.py
new file mode 100644
index 000000000..3a976a167
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/objectbucketclaim.py
@@ -0,0 +1,147 @@
+"""
+This file is automatically generated.
+Do not modify.
+"""
+
+try:
+    from typing import Any, Optional, Union, List
+except ImportError:
+    pass
+
+from .._helper import _omit, CrdObject, CrdObjectList, CrdClass
+
+class Spec(CrdObject):
+    _properties = [
+        ('storageClassName', 'storageClassName', str, False, False),
+        ('bucketName', 'bucketName', str, False, False),
+        ('generateBucketName', 'generateBucketName', str, False, False),
+        ('additionalConfig', 'additionalConfig', object, False, True),
+        ('objectBucketName', 'objectBucketName', str, False, False)
+    ]        
+
+    def __init__(self,
+                 storageClassName=_omit,  # type: Optional[str]
+                 bucketName=_omit,  # type: Optional[str]
+                 generateBucketName=_omit,  # type: Optional[str]
+                 additionalConfig=_omit,  # type: Optional[Any]
+                 objectBucketName=_omit,  # type: Optional[str]
+                 ):
+        super(Spec, self).__init__(
+            storageClassName=storageClassName,
+            bucketName=bucketName,
+            generateBucketName=generateBucketName,
+            additionalConfig=additionalConfig,
+            objectBucketName=objectBucketName,
+        )
+
+    @property
+    def storageClassName(self):
+        # type: () -> str
+        return self._property_impl('storageClassName')
+    
+    @storageClassName.setter
+    def storageClassName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._storageClassName = new_val
+    
+    @property
+    def bucketName(self):
+        # type: () -> str
+        return self._property_impl('bucketName')
+    
+    @bucketName.setter
+    def bucketName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._bucketName = new_val
+    
+    @property
+    def generateBucketName(self):
+        # type: () -> str
+        return self._property_impl('generateBucketName')
+    
+    @generateBucketName.setter
+    def generateBucketName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._generateBucketName = new_val
+    
+    @property
+    def additionalConfig(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('additionalConfig')
+    
+    @additionalConfig.setter
+    def additionalConfig(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._additionalConfig = new_val
+    
+    @property
+    def objectBucketName(self):
+        # type: () -> str
+        return self._property_impl('objectBucketName')
+    
+    @objectBucketName.setter
+    def objectBucketName(self, new_val):
+        # type: (Optional[str]) -> None
+        self._objectBucketName = new_val
+
+
+class ObjectBucketClaim(CrdClass):
+    _properties = [
+        ('spec', 'spec', 'Spec', True, False),
+        ('status', 'status', object, False, False),
+        ('apiVersion', 'apiVersion', str, True, False),
+        ('metadata', 'metadata', object, True, False)
+    ]        
+
+    def __init__(self,
+                 spec,  # type: Spec
+                 apiVersion,  # type: str
+                 metadata,  # type: Any
+                 status=_omit,  # type: Optional[Any]
+                 ):
+        super(ObjectBucketClaim, self).__init__(
+            spec=spec,
+            apiVersion=apiVersion,
+            metadata=metadata,
+            status=status,
+        )
+
+    @property
+    def spec(self):
+        # type: () -> Spec
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Spec) -> None
+        self._spec = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Any
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._status = new_val
+    
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (str) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Any
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Any) -> None
+        self._metadata = new_val
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volume.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volume.py
new file mode 100644
index 000000000..8b7c2703c
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volume.py
@@ -0,0 +1,177 @@
+"""
+This file is automatically generated.
+Do not modify.
+"""
+
+try:
+    from typing import Any, Optional, Union, List
+except ImportError:
+    pass
+
+from .._helper import _omit, CrdObject, CrdObjectList, CrdClass
+
+class AttachmentsItem(CrdObject):
+    _properties = [
+        ('clusterName', 'clusterName', str, True, False),
+        ('mountDir', 'mountDir', str, True, False),
+        ('node', 'node', str, True, False),
+        ('podName', 'podName', str, True, False),
+        ('podNamespace', 'podNamespace', str, True, False),
+        ('readOnly', 'readOnly', bool, True, False)
+    ]        
+
+    def __init__(self,
+                 clusterName,  # type: str
+                 mountDir,  # type: str
+                 node,  # type: str
+                 podName,  # type: str
+                 podNamespace,  # type: str
+                 readOnly,  # type: bool
+                 ):
+        super(AttachmentsItem, self).__init__(
+            clusterName=clusterName,
+            mountDir=mountDir,
+            node=node,
+            podName=podName,
+            podNamespace=podNamespace,
+            readOnly=readOnly,
+        )
+
+    @property
+    def clusterName(self):
+        # type: () -> str
+        return self._property_impl('clusterName')
+    
+    @clusterName.setter
+    def clusterName(self, new_val):
+        # type: (str) -> None
+        self._clusterName = new_val
+    
+    @property
+    def mountDir(self):
+        # type: () -> str
+        return self._property_impl('mountDir')
+    
+    @mountDir.setter
+    def mountDir(self, new_val):
+        # type: (str) -> None
+        self._mountDir = new_val
+    
+    @property
+    def node(self):
+        # type: () -> str
+        return self._property_impl('node')
+    
+    @node.setter
+    def node(self, new_val):
+        # type: (str) -> None
+        self._node = new_val
+    
+    @property
+    def podName(self):
+        # type: () -> str
+        return self._property_impl('podName')
+    
+    @podName.setter
+    def podName(self, new_val):
+        # type: (str) -> None
+        self._podName = new_val
+    
+    @property
+    def podNamespace(self):
+        # type: () -> str
+        return self._property_impl('podNamespace')
+    
+    @podNamespace.setter
+    def podNamespace(self, new_val):
+        # type: (str) -> None
+        self._podNamespace = new_val
+    
+    @property
+    def readOnly(self):
+        # type: () -> bool
+        return self._property_impl('readOnly')
+    
+    @readOnly.setter
+    def readOnly(self, new_val):
+        # type: (bool) -> None
+        self._readOnly = new_val
+
+
+class AttachmentsList(CrdObjectList):
+    _items_type = AttachmentsItem
+
+
+class Volume(CrdClass):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('attachments', 'attachments', 'AttachmentsList', False, False),
+        ('kind', 'kind', str, False, False),
+        ('metadata', 'metadata', object, False, False),
+        ('status', 'status', object, False, False)
+    ]        
+
+    def __init__(self,
+                 apiVersion=_omit,  # type: Optional[str]
+                 attachments=_omit,  # type: Optional[Union[List[AttachmentsItem], CrdObjectList]]
+                 kind=_omit,  # type: Optional[str]
+                 metadata=_omit,  # type: Optional[Any]
+                 status=_omit,  # type: Optional[Any]
+                 ):
+        super(Volume, self).__init__(
+            apiVersion=apiVersion,
+            attachments=attachments,
+            kind=kind,
+            metadata=metadata,
+            status=status,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def attachments(self):
+        # type: () -> Union[List[AttachmentsItem], CrdObjectList]
+        return self._property_impl('attachments')
+    
+    @attachments.setter
+    def attachments(self, new_val):
+        # type: (Optional[Union[List[AttachmentsItem], CrdObjectList]]) -> None
+        self._attachments = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Any
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._metadata = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Any
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._status = new_val
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volumereplication.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volumereplication.py
new file mode 100644
index 000000000..1b9252729
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volumereplication.py
@@ -0,0 +1,363 @@
+"""
+This file is automatically generated.
+Do not modify.
+"""
+
+try:
+    from typing import Any, Optional, Union, List
+except ImportError:
+    pass
+
+from .._helper import _omit, CrdObject, CrdObjectList, CrdClass
+
+class DataSource(CrdObject):
+    _properties = [
+        ('apiGroup', 'apiGroup', str, False, False),
+        ('kind', 'kind', str, True, False),
+        ('name', 'name', str, True, False)
+    ]        
+
+    def __init__(self,
+                 kind,  # type: str
+                 name,  # type: str
+                 apiGroup=_omit,  # type: Optional[str]
+                 ):
+        super(DataSource, self).__init__(
+            kind=kind,
+            name=name,
+            apiGroup=apiGroup,
+        )
+
+    @property
+    def apiGroup(self):
+        # type: () -> str
+        return self._property_impl('apiGroup')
+    
+    @apiGroup.setter
+    def apiGroup(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiGroup = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (str) -> None
+        self._kind = new_val
+    
+    @property
+    def name(self):
+        # type: () -> str
+        return self._property_impl('name')
+    
+    @name.setter
+    def name(self, new_val):
+        # type: (str) -> None
+        self._name = new_val
+
+
+class Spec(CrdObject):
+    _properties = [
+        ('dataSource', 'dataSource', 'DataSource', True, False),
+        ('replicationState', 'replicationState', str, True, False),
+        ('volumeReplicationClass', 'volumeReplicationClass', str, True, False)
+    ]        
+
+    def __init__(self,
+                 dataSource,  # type: DataSource
+                 replicationState,  # type: str
+                 volumeReplicationClass,  # type: str
+                 ):
+        super(Spec, self).__init__(
+            dataSource=dataSource,
+            replicationState=replicationState,
+            volumeReplicationClass=volumeReplicationClass,
+        )
+
+    @property
+    def dataSource(self):
+        # type: () -> DataSource
+        return self._property_impl('dataSource')
+    
+    @dataSource.setter
+    def dataSource(self, new_val):
+        # type: (DataSource) -> None
+        self._dataSource = new_val
+    
+    @property
+    def replicationState(self):
+        # type: () -> str
+        return self._property_impl('replicationState')
+    
+    @replicationState.setter
+    def replicationState(self, new_val):
+        # type: (str) -> None
+        self._replicationState = new_val
+    
+    @property
+    def volumeReplicationClass(self):
+        # type: () -> str
+        return self._property_impl('volumeReplicationClass')
+    
+    @volumeReplicationClass.setter
+    def volumeReplicationClass(self, new_val):
+        # type: (str) -> None
+        self._volumeReplicationClass = new_val
+
+
+class ConditionsItem(CrdObject):
+    _properties = [
+        ('lastTransitionTime', 'lastTransitionTime', str, True, False),
+        ('message', 'message', str, True, False),
+        ('observedGeneration', 'observedGeneration', int, False, False),
+        ('reason', 'reason', str, True, False),
+        ('status', 'status', str, True, False),
+        ('type', 'type', str, True, False)
+    ]        
+
+    def __init__(self,
+                 lastTransitionTime,  # type: str
+                 message,  # type: str
+                 reason,  # type: str
+                 status,  # type: str
+                 type,  # type: str
+                 observedGeneration=_omit,  # type: Optional[int]
+                 ):
+        super(ConditionsItem, self).__init__(
+            lastTransitionTime=lastTransitionTime,
+            message=message,
+            reason=reason,
+            status=status,
+            type=type,
+            observedGeneration=observedGeneration,
+        )
+
+    @property
+    def lastTransitionTime(self):
+        # type: () -> str
+        return self._property_impl('lastTransitionTime')
+    
+    @lastTransitionTime.setter
+    def lastTransitionTime(self, new_val):
+        # type: (str) -> None
+        self._lastTransitionTime = new_val
+    
+    @property
+    def message(self):
+        # type: () -> str
+        return self._property_impl('message')
+    
+    @message.setter
+    def message(self, new_val):
+        # type: (str) -> None
+        self._message = new_val
+    
+    @property
+    def observedGeneration(self):
+        # type: () -> int
+        return self._property_impl('observedGeneration')
+    
+    @observedGeneration.setter
+    def observedGeneration(self, new_val):
+        # type: (Optional[int]) -> None
+        self._observedGeneration = new_val
+    
+    @property
+    def reason(self):
+        # type: () -> str
+        return self._property_impl('reason')
+    
+    @reason.setter
+    def reason(self, new_val):
+        # type: (str) -> None
+        self._reason = new_val
+    
+    @property
+    def status(self):
+        # type: () -> str
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (str) -> None
+        self._status = new_val
+    
+    @property
+    def type(self):
+        # type: () -> str
+        return self._property_impl('type')
+    
+    @type.setter
+    def type(self, new_val):
+        # type: (str) -> None
+        self._type = new_val
+
+
+class ConditionsList(CrdObjectList):
+    _items_type = ConditionsItem
+
+
+class Status(CrdObject):
+    _properties = [
+        ('conditions', 'conditions', 'ConditionsList', False, False),
+        ('lastCompletionTime', 'lastCompletionTime', str, False, False),
+        ('lastStartTime', 'lastStartTime', str, False, False),
+        ('message', 'message', str, False, False),
+        ('observedGeneration', 'observedGeneration', int, False, False),
+        ('state', 'state', str, False, False)
+    ]        
+
+    def __init__(self,
+                 conditions=_omit,  # type: Optional[Union[List[ConditionsItem], CrdObjectList]]
+                 lastCompletionTime=_omit,  # type: Optional[str]
+                 lastStartTime=_omit,  # type: Optional[str]
+                 message=_omit,  # type: Optional[str]
+                 observedGeneration=_omit,  # type: Optional[int]
+                 state=_omit,  # type: Optional[str]
+                 ):
+        super(Status, self).__init__(
+            conditions=conditions,
+            lastCompletionTime=lastCompletionTime,
+            lastStartTime=lastStartTime,
+            message=message,
+            observedGeneration=observedGeneration,
+            state=state,
+        )
+
+    @property
+    def conditions(self):
+        # type: () -> Union[List[ConditionsItem], CrdObjectList]
+        return self._property_impl('conditions')
+    
+    @conditions.setter
+    def conditions(self, new_val):
+        # type: (Optional[Union[List[ConditionsItem], CrdObjectList]]) -> None
+        self._conditions = new_val
+    
+    @property
+    def lastCompletionTime(self):
+        # type: () -> str
+        return self._property_impl('lastCompletionTime')
+    
+    @lastCompletionTime.setter
+    def lastCompletionTime(self, new_val):
+        # type: (Optional[str]) -> None
+        self._lastCompletionTime = new_val
+    
+    @property
+    def lastStartTime(self):
+        # type: () -> str
+        return self._property_impl('lastStartTime')
+    
+    @lastStartTime.setter
+    def lastStartTime(self, new_val):
+        # type: (Optional[str]) -> None
+        self._lastStartTime = new_val
+    
+    @property
+    def message(self):
+        # type: () -> str
+        return self._property_impl('message')
+    
+    @message.setter
+    def message(self, new_val):
+        # type: (Optional[str]) -> None
+        self._message = new_val
+    
+    @property
+    def observedGeneration(self):
+        # type: () -> int
+        return self._property_impl('observedGeneration')
+    
+    @observedGeneration.setter
+    def observedGeneration(self, new_val):
+        # type: (Optional[int]) -> None
+        self._observedGeneration = new_val
+    
+    @property
+    def state(self):
+        # type: () -> str
+        return self._property_impl('state')
+    
+    @state.setter
+    def state(self, new_val):
+        # type: (Optional[str]) -> None
+        self._state = new_val
+
+
+class VolumeReplication(CrdClass):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('kind', 'kind', str, False, False),
+        ('metadata', 'metadata', object, False, False),
+        ('spec', 'spec', 'Spec', True, False),
+        ('status', 'status', 'Status', False, False)
+    ]        
+
+    def __init__(self,
+                 spec,  # type: Spec
+                 apiVersion=_omit,  # type: Optional[str]
+                 kind=_omit,  # type: Optional[str]
+                 metadata=_omit,  # type: Optional[Any]
+                 status=_omit,  # type: Optional[Status]
+                 ):
+        super(VolumeReplication, self).__init__(
+            spec=spec,
+            apiVersion=apiVersion,
+            kind=kind,
+            metadata=metadata,
+            status=status,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Any
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._metadata = new_val
+    
+    @property
+    def spec(self):
+        # type: () -> Spec
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Spec) -> None
+        self._spec = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Status
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Status]) -> None
+        self._status = new_val
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volumereplicationclass.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volumereplicationclass.py
new file mode 100644
index 000000000..842a131e1
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volumereplicationclass.py
@@ -0,0 +1,121 @@
+"""
+This file is automatically generated.
+Do not modify.
+"""
+
+try:
+    from typing import Any, Optional, Union, List
+except ImportError:
+    pass
+
+from .._helper import _omit, CrdObject, CrdObjectList, CrdClass
+
+class Spec(CrdObject):
+    _properties = [
+        ('parameters', 'parameters', object, False, False),
+        ('provisioner', 'provisioner', str, True, False)
+    ]        
+
+    def __init__(self,
+                 provisioner,  # type: str
+                 parameters=_omit,  # type: Optional[Any]
+                 ):
+        super(Spec, self).__init__(
+            provisioner=provisioner,
+            parameters=parameters,
+        )
+
+    @property
+    def parameters(self):
+        # type: () -> Any
+        return self._property_impl('parameters')
+    
+    @parameters.setter
+    def parameters(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._parameters = new_val
+    
+    @property
+    def provisioner(self):
+        # type: () -> str
+        return self._property_impl('provisioner')
+    
+    @provisioner.setter
+    def provisioner(self, new_val):
+        # type: (str) -> None
+        self._provisioner = new_val
+
+
+class VolumeReplicationClass(CrdClass):
+    _properties = [
+        ('apiVersion', 'apiVersion', str, False, False),
+        ('kind', 'kind', str, False, False),
+        ('metadata', 'metadata', object, False, False),
+        ('spec', 'spec', 'Spec', True, False),
+        ('status', 'status', object, False, False)
+    ]        
+
+    def __init__(self,
+                 spec,  # type: Spec
+                 apiVersion=_omit,  # type: Optional[str]
+                 kind=_omit,  # type: Optional[str]
+                 metadata=_omit,  # type: Optional[Any]
+                 status=_omit,  # type: Optional[Any]
+                 ):
+        super(VolumeReplicationClass, self).__init__(
+            spec=spec,
+            apiVersion=apiVersion,
+            kind=kind,
+            metadata=metadata,
+            status=status,
+        )
+
+    @property
+    def apiVersion(self):
+        # type: () -> str
+        return self._property_impl('apiVersion')
+    
+    @apiVersion.setter
+    def apiVersion(self, new_val):
+        # type: (Optional[str]) -> None
+        self._apiVersion = new_val
+    
+    @property
+    def kind(self):
+        # type: () -> str
+        return self._property_impl('kind')
+    
+    @kind.setter
+    def kind(self, new_val):
+        # type: (Optional[str]) -> None
+        self._kind = new_val
+    
+    @property
+    def metadata(self):
+        # type: () -> Any
+        return self._property_impl('metadata')
+    
+    @metadata.setter
+    def metadata(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._metadata = new_val
+    
+    @property
+    def spec(self):
+        # type: () -> Spec
+        return self._property_impl('spec')
+    
+    @spec.setter
+    def spec(self, new_val):
+        # type: (Spec) -> None
+        self._spec = new_val
+    
+    @property
+    def status(self):
+        # type: () -> Any
+        return self._property_impl('status')
+    
+    @status.setter
+    def status(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._status = new_val
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/py.typed b/src/pybind/mgr/rook/rook-client-python/rook_client/py.typed
new file mode 100644
index 000000000..80dd90bf1
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/py.typed
@@ -0,0 +1 @@
+# Marker file for PEP 561.  This package uses inline types.
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/tests/__init__.py b/src/pybind/mgr/rook/rook-client-python/rook_client/tests/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/tests/__init__.py
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_README.py b/src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_README.py
new file mode 100644
index 000000000..50d6c41b4
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_README.py
@@ -0,0 +1,28 @@
+def objectstore(api_name, name, namespace, instances):
+    from rook_client.ceph import cephobjectstore as cos
+    rook_os = cos.CephObjectStore(
+        apiVersion=api_name,
+        metadata=dict(
+            name=name,
+            namespace=namespace
+        ),
+        spec=cos.Spec(
+            metadataPool=cos.MetadataPool(
+                failureDomain='host',
+                replicated=cos.Replicated(
+                    size=1
+                )
+            ),
+            dataPool=cos.DataPool(
+                failureDomain='osd',
+                replicated=cos.Replicated(
+                    size=1
+                )
+            ),
+            gateway=cos.Gateway(
+                port=80,
+                instances=instances
+            )
+        )
+    )
+    return rook_os.to_json()
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_examples.py b/src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_examples.py
new file mode 100644
index 000000000..5367844ec
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_examples.py
@@ -0,0 +1,52 @@
+from os.path import expanduser, dirname, realpath
+
+import yaml
+import pytest
+
+import rook_client
+from rook_client.cassandra.cluster import Cluster as CassandraCluster
+from rook_client.ceph.cephcluster import CephCluster
+from rook_client.ceph.cephfilesystem import CephFilesystem
+from rook_client.ceph.cephnfs import CephNFS
+from rook_client.ceph.cephobjectstore import CephObjectStore
+from rook_client.ceph.cephblockpool import CephBlockPool
+
+
+def _load_example(crd_base, what):
+    with open(expanduser('{crd_base}/{what}').format(crd_base=crd_base, what=what)) as f:
+        return f.read()
+
+
+@pytest.mark.parametrize(
+    "strict,cls,filename",
+    [
+        (True, CephCluster, "ceph/cluster-external.yaml"),
+        (True, CephCluster, "ceph/cluster-on-pvc.yaml"),
+        (True, CephCluster, "ceph/cluster.yaml"),
+        (True, CephFilesystem, "ceph/filesystem-ec.yaml"),
+        (True, CephFilesystem, "ceph/filesystem-test.yaml"),
+        (True, CephFilesystem, "ceph/filesystem.yaml"),
+        (True, CephObjectStore, "ceph/object-ec.yaml"),
+        (True, CephObjectStore, "ceph/object-openshift.yaml"),
+        (True, CephObjectStore, "ceph/object-test.yaml"),
+        (True, CephObjectStore, "ceph/object.yaml"),
+        (True, CephNFS, "ceph/nfs.yaml"),
+        (True, CephBlockPool, "ceph/pool.yaml"),
+        (True, CephBlockPool, "ceph/pool-ec.yaml"),
+        (True, CephBlockPool, "ceph/pool-test.yaml"),
+
+        # schema invalid:
+        # (False, CassandraCluster, "cassandra/cluster.yaml"),
+    ],
+)
+def test_exact_match(strict, cls, filename, crd_base):
+    crds = yaml.safe_load_all(_load_example(crd_base, filename))
+    rook_client.STRICT = strict
+    [crd] = [e for e in crds if e.get('kind', '') == cls.__name__]
+
+    c = cls.from_json(crd)
+    assert crd == c.to_json()
+
+
+
+
diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_properties.py b/src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_properties.py
new file mode 100644
index 000000000..0d580e43f
--- /dev/null
+++ b/src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_properties.py
@@ -0,0 +1,13 @@
+from copy import deepcopy
+
+import pytest
+
+from rook_client.ceph import cephcluster as cc
+
+
+def test_omit():
+    cv = cc.CephVersion()
+    with pytest.raises(AttributeError):
+        cv.allowUnsupported
+
+    assert not hasattr(cv, 'allowUnsupported')