import quincy beta 17.1.0

[ceph.git] / ceph / src / pybind / mgr / rook / rook-client-python / rook_client / ceph / cephobjectstore.py

diff --git a/ceph/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectstore.py b/ceph/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectstore.py
index 025080929e252089ae1f102e76f7c024ab90de46..2c7d7cb74aec4573e5a5c9c5fa16e89fabb165fe 100644 (file)
--- a/ceph/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectstore.py
+++ b/ceph/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectstore.py
@@ -10,58 +10,1604 @@ except ImportError:
 
 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 = [
-        ('type', 'type', str, False, False),
-        ('sslCertificateRef', 'sslCertificateRef', object, False, False),
+        ('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),
-        ('securePort', 'securePort', object, False, False),
-        ('instances', 'instances', int, False, False),
-        ('annotations', 'annotations', object, False, False),
-        ('placement', 'placement', object, False, False),
-        ('resources', 'resources', object, 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,
-                 type=_omit,  # type: Optional[str]
-                 sslCertificateRef=_omit,  # type: Optional[Any]
-                 port=_omit,  # type: Optional[int]
-                 securePort=_omit,  # type: Optional[Any]
-                 instances=_omit,  # type: Optional[int]
+                 instances,  # type: int
                  annotations=_omit,  # type: Optional[Any]
-                 placement=_omit,  # type: Optional[Any]
-                 resources=_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__(
-            type=type,
-            sslCertificateRef=sslCertificateRef,
-            port=port,
-            securePort=securePort,
             instances=instances,
             annotations=annotations,
+            externalRgwEndpoints=externalRgwEndpoints,
+            labels=labels,
             placement=placement,
+            port=port,
+            priorityClassName=priorityClassName,
             resources=resources,
+            securePort=securePort,
+            service=service,
+            sslCertificateRef=sslCertificateRef,
         )
 
     @property
-    def type(self):
-        # type: () -> str
-        return self._property_impl('type')
+    def annotations(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('annotations')
     
-    @type.setter
-    def type(self, new_val):
-        # type: (Optional[str]) -> None
-        self._type = new_val
+    @annotations.setter
+    def annotations(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._annotations = new_val
     
     @property
-    def sslCertificateRef(self):
-        # type: () -> Any
-        return self._property_impl('sslCertificateRef')
+    def externalRgwEndpoints(self):
+        # type: () -> Optional[Union[List[ExternalRgwEndpointsItem], CrdObjectList]]
+        return self._property_impl('externalRgwEndpoints')
     
-    @sslCertificateRef.setter
-    def sslCertificateRef(self, new_val):
+    @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._sslCertificateRef = new_val
+        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):
@@ -73,134 +1619,575 @@ class Gateway(CrdObject):
         # 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: () -> Any
+        # type: () -> Optional[int]
         return self._property_impl('securePort')
     
     @securePort.setter
     def securePort(self, new_val):
-        # type: (Optional[Any]) -> None
+        # type: (Optional[int]) -> None
         self._securePort = new_val
     
     @property
-    def instances(self):
+    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('instances')
+        return self._property_impl('failureThreshold')
     
-    @instances.setter
-    def instances(self, new_val):
+    @failureThreshold.setter
+    def failureThreshold(self, new_val):
         # type: (Optional[int]) -> None
-        self._instances = new_val
+        self._failureThreshold = new_val
     
     @property
-    def annotations(self):
-        # type: () -> Any
-        return self._property_impl('annotations')
+    def httpGet(self):
+        # type: () -> HttpGet
+        return self._property_impl('httpGet')
     
-    @annotations.setter
-    def annotations(self, new_val):
-        # type: (Optional[Any]) -> None
-        self._annotations = new_val
+    @httpGet.setter
+    def httpGet(self, new_val):
+        # type: (Optional[HttpGet]) -> None
+        self._httpGet = new_val
     
     @property
-    def placement(self):
-        # type: () -> Any
-        return self._property_impl('placement')
+    def initialDelaySeconds(self):
+        # type: () -> int
+        return self._property_impl('initialDelaySeconds')
     
-    @placement.setter
-    def placement(self, new_val):
-        # type: (Optional[Any]) -> None
-        self._placement = new_val
+    @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 resources(self):
-        # type: () -> Any
-        return self._property_impl('resources')
+    def timeoutSeconds(self):
+        # type: () -> int
+        return self._property_impl('timeoutSeconds')
     
-    @resources.setter
-    def resources(self, new_val):
-        # type: (Optional[Any]) -> None
-        self._resources = new_val
+    @timeoutSeconds.setter
+    def timeoutSeconds(self, new_val):
+        # type: (Optional[int]) -> None
+        self._timeoutSeconds = new_val
 
 
-class Replicated(CrdObject):
+class LivenessProbe(CrdObject):
     _properties = [
-        ('size', 'size', int, False, False)
+        ('disabled', 'disabled', bool, False, False),
+        ('probe', 'probe', 'Probe', False, False)
     ]        
 
     def __init__(self,
-                 size=_omit,  # type: Optional[int]
+                 disabled=_omit,  # type: Optional[bool]
+                 probe=_omit,  # type: Optional[Probe]
                  ):
-        super(Replicated, self).__init__(
-            size=size,
+        super(LivenessProbe, self).__init__(
+            disabled=disabled,
+            probe=probe,
         )
 
     @property
-    def size(self):
-        # type: () -> int
-        return self._property_impl('size')
+    def disabled(self):
+        # type: () -> bool
+        return self._property_impl('disabled')
     
-    @size.setter
-    def size(self, new_val):
-        # type: (Optional[int]) -> None
-        self._size = new_val
+    @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 ErasureCoded(CrdObject):
+class HealthCheck(CrdObject):
     _properties = [
-        ('dataChunks', 'dataChunks', int, False, False),
-        ('codingChunks', 'codingChunks', int, False, False)
+        ('bucket', 'bucket', 'Bucket', False, False),
+        ('livenessProbe', 'livenessProbe', 'LivenessProbe', False, False)
     ]        
 
     def __init__(self,
-                 dataChunks=_omit,  # type: Optional[int]
-                 codingChunks=_omit,  # type: Optional[int]
+                 bucket=_omit,  # type: Optional[Bucket]
+                 livenessProbe=_omit,  # type: Optional[LivenessProbe]
                  ):
-        super(ErasureCoded, self).__init__(
-            dataChunks=dataChunks,
-            codingChunks=codingChunks,
+        super(HealthCheck, self).__init__(
+            bucket=bucket,
+            livenessProbe=livenessProbe,
         )
 
     @property
-    def dataChunks(self):
-        # type: () -> int
-        return self._property_impl('dataChunks')
+    def bucket(self):
+        # type: () -> Bucket
+        return self._property_impl('bucket')
     
-    @dataChunks.setter
-    def dataChunks(self, new_val):
-        # type: (Optional[int]) -> None
-        self._dataChunks = new_val
+    @bucket.setter
+    def bucket(self, new_val):
+        # type: (Optional[Bucket]) -> None
+        self._bucket = new_val
     
     @property
-    def codingChunks(self):
-        # type: () -> int
-        return self._property_impl('codingChunks')
+    def livenessProbe(self):
+        # type: () -> LivenessProbe
+        return self._property_impl('livenessProbe')
     
-    @codingChunks.setter
-    def codingChunks(self, new_val):
-        # type: (Optional[int]) -> None
-        self._codingChunks = new_val
+    @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),
-        ('replicated', 'replicated', Replicated, False, False),
-        ('erasureCoded', 'erasureCoded', ErasureCoded, 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]
-                 erasureCoded=_omit,  # type: Optional[ErasureCoded]
+                 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,
-            erasureCoded=erasureCoded,
+            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
@@ -211,6 +2198,36 @@ class MetadataPool(CrdObject):
         # 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
@@ -222,89 +2239,141 @@ class MetadataPool(CrdObject):
         self._replicated = new_val
     
     @property
-    def erasureCoded(self):
-        # type: () -> ErasureCoded
-        return self._property_impl('erasureCoded')
+    def statusCheck(self):
+        # type: () -> StatusCheck
+        return self._property_impl('statusCheck')
     
-    @erasureCoded.setter
-    def erasureCoded(self, new_val):
-        # type: (Optional[ErasureCoded]) -> None
-        self._erasureCoded = new_val
+    @statusCheck.setter
+    def statusCheck(self, new_val):
+        # type: (Optional[StatusCheck]) -> None
+        self._statusCheck = new_val
 
 
-class DataPool(CrdObject):
+class Kms(CrdObject):
     _properties = [
-        ('failureDomain', 'failureDomain', str, False, False),
-        ('replicated', 'replicated', Replicated, False, False),
-        ('erasureCoded', 'erasureCoded', ErasureCoded, False, False)
+        ('connectionDetails', 'connectionDetails', object, False, True),
+        ('tokenSecretName', 'tokenSecretName', str, False, False)
     ]        
 
     def __init__(self,
-                 failureDomain=_omit,  # type: Optional[str]
-                 replicated=_omit,  # type: Optional[Replicated]
-                 erasureCoded=_omit,  # type: Optional[ErasureCoded]
+                 connectionDetails=_omit,  # type: Optional[Any]
+                 tokenSecretName=_omit,  # type: Optional[str]
                  ):
-        super(DataPool, self).__init__(
-            failureDomain=failureDomain,
-            replicated=replicated,
-            erasureCoded=erasureCoded,
+        super(Kms, self).__init__(
+            connectionDetails=connectionDetails,
+            tokenSecretName=tokenSecretName,
         )
 
     @property
-    def failureDomain(self):
-        # type: () -> str
-        return self._property_impl('failureDomain')
+    def connectionDetails(self):
+        # type: () -> Optional[Any]
+        return self._property_impl('connectionDetails')
     
-    @failureDomain.setter
-    def failureDomain(self, new_val):
-        # type: (Optional[str]) -> None
-        self._failureDomain = new_val
+    @connectionDetails.setter
+    def connectionDetails(self, new_val):
+        # type: (Optional[Any]) -> None
+        self._connectionDetails = new_val
     
     @property
-    def replicated(self):
-        # type: () -> Replicated
-        return self._property_impl('replicated')
+    def tokenSecretName(self):
+        # type: () -> str
+        return self._property_impl('tokenSecretName')
     
-    @replicated.setter
-    def replicated(self, new_val):
-        # type: (Optional[Replicated]) -> None
-        self._replicated = new_val
+    @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 erasureCoded(self):
-        # type: () -> ErasureCoded
-        return self._property_impl('erasureCoded')
+    def name(self):
+        # type: () -> str
+        return self._property_impl('name')
     
-    @erasureCoded.setter
-    def erasureCoded(self, new_val):
-        # type: (Optional[ErasureCoded]) -> None
-        self._erasureCoded = new_val
+    @name.setter
+    def name(self, new_val):
+        # type: (str) -> None
+        self._name = new_val
 
 
 class Spec(CrdObject):
     _properties = [
-        ('gateway', 'gateway', Gateway, False, False),
-        ('metadataPool', 'metadataPool', MetadataPool, False, False),
-        ('dataPool', 'dataPool', DataPool, False, False),
-        ('preservePoolsOnDelete', 'preservePoolsOnDelete', bool, False, False)
+        ('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]
-                 dataPool=_omit,  # type: Optional[DataPool]
                  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,
-            dataPool=dataPool,
             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: () -> Gateway
+        # type: () -> Optional[Gateway]
         return self._property_impl('gateway')
     
     @gateway.setter
@@ -312,9 +2381,19 @@ class Spec(CrdObject):
         # 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: () -> MetadataPool
+        # type: () -> Optional[MetadataPool]
         return self._property_impl('metadataPool')
     
     @metadataPool.setter
@@ -322,16 +2401,6 @@ class Spec(CrdObject):
         # type: (Optional[MetadataPool]) -> None
         self._metadataPool = new_val
     
-    @property
-    def dataPool(self):
-        # type: () -> DataPool
-        return self._property_impl('dataPool')
-    
-    @dataPool.setter
-    def dataPool(self, new_val):
-        # type: (Optional[DataPool]) -> None
-        self._dataPool = new_val
-    
     @property
     def preservePoolsOnDelete(self):
         # type: () -> bool
@@ -341,26 +2410,173 @@ class Spec(CrdObject):
     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, True, False),
-        ('metadata', 'metadata', object, True, False),
-        ('status', 'status', object, False, False),
-        ('spec', 'spec', Spec, True, False)
+        ('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,
-                 apiVersion,  # type: str
-                 metadata,  # type: Any
                  spec,  # type: Spec
-                 status=_omit,  # type: Optional[Any]
+                 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,
-            spec=spec,
             status=status,
         )
 
@@ -371,9 +2587,19 @@ class CephObjectStore(CrdClass):
     
     @apiVersion.setter
     def apiVersion(self, new_val):
-        # type: (str) -> None
+        # 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
@@ -381,18 +2607,8 @@ class CephObjectStore(CrdClass):
     
     @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
+        self._metadata = new_val
     
     @property
     def spec(self):
@@ -403,3 +2619,13 @@ class CephObjectStore(CrdClass):
     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