import quincy beta 17.1.0

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

"""
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