def __init__(self,
                 comments=None,
                 href=None,
                 method='POST',
                 rel=None,
                 local_vars_configuration=None):  # noqa: E501
        """HyperflexHxLinkDtAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._comments = None
        self._href = None
        self._method = None
        self._rel = None
        self.discriminator = None

        if comments is not None:
            self.comments = comments
        if href is not None:
            self.href = href
        if method is not None:
            self.method = method
        if rel is not None:
            self.rel = rel
Esempio n. 2
0
    def __init__(self,
                 boot_devices=None,
                 configured_boot_mode='Legacy',
                 enforce_uefi_secure_boot=None,
                 organization=None,
                 profiles=None,
                 local_vars_configuration=None):  # noqa: E501
        """BootPrecisionPolicyAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._boot_devices = None
        self._configured_boot_mode = None
        self._enforce_uefi_secure_boot = None
        self._organization = None
        self._profiles = None
        self.discriminator = None

        if boot_devices is not None:
            self.boot_devices = boot_devices
        if configured_boot_mode is not None:
            self.configured_boot_mode = configured_boot_mode
        if enforce_uefi_secure_boot is not None:
            self.enforce_uefi_secure_boot = enforce_uefi_secure_boot
        if organization is not None:
            self.organization = organization
        if profiles is not None:
            self.profiles = profiles
Esempio n. 3
0
    def __init__(self,
                 data_reduction=None,
                 snapshot=None,
                 thin_provisioned=None,
                 total_reduction=None,
                 volume=None,
                 local_vars_configuration=None):  # noqa: E501
        """StorageStorageUtilizationAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._data_reduction = None
        self._snapshot = None
        self._thin_provisioned = None
        self._total_reduction = None
        self._volume = None
        self.discriminator = None

        if data_reduction is not None:
            self.data_reduction = data_reduction
        if snapshot is not None:
            self.snapshot = snapshot
        if thin_provisioned is not None:
            self.thin_provisioned = thin_provisioned
        if total_reduction is not None:
            self.total_reduction = total_reduction
        if volume is not None:
            self.volume = volume
    def __init__(self,
                 config_state=None,
                 control_action=None,
                 error_state=None,
                 oper_state=None,
                 local_vars_configuration=None):  # noqa: E501
        """PolicyConfigContextAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._config_state = None
        self._control_action = None
        self._error_state = None
        self._oper_state = None
        self.discriminator = None

        if config_state is not None:
            self.config_state = config_state
        if control_action is not None:
            self.control_action = control_action
        if error_state is not None:
            self.error_state = error_state
        if oper_state is not None:
            self.oper_state = oper_state
    def __init__(self,
                 catalog_moid=None,
                 task_definition_id=None,
                 task_definition_name=None,
                 version=None,
                 local_vars_configuration=None):  # noqa: E501
        """WorkflowWorkerTaskAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._catalog_moid = None
        self._task_definition_id = None
        self._task_definition_name = None
        self._version = None
        self.discriminator = None

        if catalog_moid is not None:
            self.catalog_moid = catalog_moid
        if task_definition_id is not None:
            self.task_definition_id = task_definition_id
        if task_definition_name is not None:
            self.task_definition_name = task_definition_name
        if version is not None:
            self.version = version
Esempio n. 6
0
    def __init__(self,
                 accept_single_value=None,
                 complex_type=None,
                 item_type='simple',
                 name=None,
                 path=None,
                 type='simple',
                 local_vars_configuration=None):  # noqa: E501
        """ContentBaseParameterAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._accept_single_value = None
        self._complex_type = None
        self._item_type = None
        self._name = None
        self._path = None
        self._type = None
        self.discriminator = None

        if accept_single_value is not None:
            self.accept_single_value = accept_single_value
        if complex_type is not None:
            self.complex_type = complex_type
        if item_type is not None:
            self.item_type = item_type
        if name is not None:
            self.name = name
        if path is not None:
            self.path = path
        if type is not None:
            self.type = type
    def __init__(self,
                 coalescing_time=None,
                 coalescing_type='MIN',
                 count=None,
                 mode='MSIx',
                 local_vars_configuration=None):  # noqa: E501
        """VnicEthInterruptSettingsAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._coalescing_time = None
        self._coalescing_type = None
        self._count = None
        self._mode = None
        self.discriminator = None

        if coalescing_time is not None:
            self.coalescing_time = coalescing_time
        if coalescing_type is not None:
            self.coalescing_type = coalescing_type
        if count is not None:
            self.count = count
        if mode is not None:
            self.mode = mode
    def __init__(self,
                 oper_state=None,
                 presence=None,
                 compute_blade=None,
                 registered_device=None,
                 local_vars_configuration=None):  # noqa: E501
        """EquipmentIoExpanderAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._oper_state = None
        self._presence = None
        self._compute_blade = None
        self._registered_device = None
        self.discriminator = None

        if oper_state is not None:
            self.oper_state = oper_state
        if presence is not None:
            self.presence = presence
        if compute_blade is not None:
            self.compute_blade = compute_blade
        if registered_device is not None:
            self.registered_device = registered_device
Esempio n. 9
0
    def __init__(self,
                 transceiver_type=None,
                 wwn=None,
                 port_group=None,
                 registered_device=None,
                 local_vars_configuration=None):  # noqa: E501
        """FcPhysicalPortAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._transceiver_type = None
        self._wwn = None
        self._port_group = None
        self._registered_device = None
        self.discriminator = None

        if transceiver_type is not None:
            self.transceiver_type = transceiver_type
        if wwn is not None:
            self.wwn = wwn
        if port_group is not None:
            self.port_group = port_group
        if registered_device is not None:
            self.registered_device = registered_device
    def __init__(self,
                 mount_options=None,
                 remote_file=None,
                 remote_ip=None,
                 remote_share=None,
                 local_vars_configuration=None):  # noqa: E501
        """FirmwareNfsServerAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._mount_options = None
        self._remote_file = None
        self._remote_ip = None
        self._remote_share = None
        self.discriminator = None

        if mount_options is not None:
            self.mount_options = mount_options
        if remote_file is not None:
            self.remote_file = remote_file
        if remote_ip is not None:
            self.remote_ip = remote_ip
        if remote_share is not None:
            self.remote_share = remote_share
Esempio n. 11
0
    def __init__(self,
                 enable=None,
                 name=None,
                 account=None,
                 parent_config=None,
                 sub_configs=None,
                 local_vars_configuration=None):  # noqa: E501
        """ApplianceDataExportPolicyAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._enable = None
        self._name = None
        self._account = None
        self._parent_config = None
        self._sub_configs = None
        self.discriminator = None

        if enable is not None:
            self.enable = enable
        if name is not None:
            self.name = name
        if account is not None:
            self.account = account
        if parent_config is not None:
            self.parent_config = parent_config
        if sub_configs is not None:
            self.sub_configs = sub_configs
    def __init__(self,
                 interested_mos=None,
                 ref_mo=None,
                 timestamp=None,
                 version=None,
                 version_type='Modified',
                 local_vars_configuration=None):  # noqa: E501
        """MoVersionContextAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._interested_mos = None
        self._ref_mo = None
        self._timestamp = None
        self._version = None
        self._version_type = None
        self.discriminator = None

        if interested_mos is not None:
            self.interested_mos = interested_mos
        if ref_mo is not None:
            self.ref_mo = ref_mo
        if timestamp is not None:
            self.timestamp = timestamp
        if version is not None:
            self.version = version
        if version_type is not None:
            self.version_type = version_type
    def __init__(self,
                 large_receive=None,
                 large_send=None,
                 rx_checksum=None,
                 tx_checksum=None,
                 local_vars_configuration=None):  # noqa: E501
        """VnicTcpOffloadSettingsAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._large_receive = None
        self._large_send = None
        self._rx_checksum = None
        self._tx_checksum = None
        self.discriminator = None

        if large_receive is not None:
            self.large_receive = large_receive
        if large_send is not None:
            self.large_send = large_send
        if rx_checksum is not None:
            self.rx_checksum = rx_checksum
        if tx_checksum is not None:
            self.tx_checksum = tx_checksum
Esempio n. 14
0
    def __init__(self,
                 dedicated_hot_spares=None,
                 raid_level='Raid0',
                 span_groups=None,
                 use_jbods=None,
                 organization=None,
                 storage_policies=None,
                 local_vars_configuration=None):  # noqa: E501
        """StorageDiskGroupPolicyAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._dedicated_hot_spares = None
        self._raid_level = None
        self._span_groups = None
        self._use_jbods = None
        self._organization = None
        self._storage_policies = None
        self.discriminator = None

        if dedicated_hot_spares is not None:
            self.dedicated_hot_spares = dedicated_hot_spares
        if raid_level is not None:
            self.raid_level = raid_level
        if span_groups is not None:
            self.span_groups = span_groups
        if use_jbods is not None:
            self.use_jbods = use_jbods
        if organization is not None:
            self.organization = organization
        if storage_policies is not None:
            self.storage_policies = storage_policies
Esempio n. 15
0
    def __init__(self,
                 post_date=None,
                 post_detail=None,
                 post_type=None,
                 postid=None,
                 revision=None,
                 local_vars_configuration=None):  # noqa: E501
        """NiaapiNewReleasePostAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._post_date = None
        self._post_detail = None
        self._post_type = None
        self._postid = None
        self._revision = None
        self.discriminator = None

        if post_date is not None:
            self.post_date = post_date
        if post_detail is not None:
            self.post_detail = post_detail
        if post_type is not None:
            self.post_type = post_type
        if postid is not None:
            self.postid = postid
        if revision is not None:
            self.revision = revision
Esempio n. 16
0
    def __init__(self,
                 content=None,
                 date=None,
                 metadata_chksum=None,
                 metadata_filename=None,
                 version=None,
                 local_vars_configuration=None):  # noqa: E501
        """NiaapiNiaMetadataAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._date = None
        self._metadata_chksum = None
        self._metadata_filename = None
        self._version = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if date is not None:
            self.date = date
        if metadata_chksum is not None:
            self.metadata_chksum = metadata_chksum
        if metadata_filename is not None:
            self.metadata_filename = metadata_filename
        if version is not None:
            self.version = version
Esempio n. 17
0
    def __init__(self,
                 dn=None,
                 target_mo_id=None,
                 target_mo_type=None,
                 registered_device=None,
                 local_vars_configuration=None):  # noqa: E501
        """InventoryDnMoBindingAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._dn = None
        self._target_mo_id = None
        self._target_mo_type = None
        self._registered_device = None
        self.discriminator = None

        if dn is not None:
            self.dn = dn
        if target_mo_id is not None:
            self.target_mo_id = target_mo_id
        if target_mo_type is not None:
            self.target_mo_type = target_mo_type
        if registered_device is not None:
            self.registered_device = registered_device
    def __init__(self,
                 enabled=None,
                 is_encryption_key_set=None,
                 encryption_key=None,
                 privilege='admin',
                 organization=None,
                 profiles=None,
                 local_vars_configuration=None):  # noqa: E501
        """IpmioverlanPolicyAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._enabled = None
        self._is_encryption_key_set = None
        self._encryption_key = None
        self._privilege = None
        self._organization = None
        self._profiles = None
        self.discriminator = None

        if enabled is not None:
            self.enabled = enabled
        if is_encryption_key_set is not None:
            self.is_encryption_key_set = is_encryption_key_set
        if encryption_key is not None:
            self.encryption_key = encryption_key
        if privilege is not None:
            self.privilege = privilege
        if organization is not None:
            self.organization = organization
        if profiles is not None:
            self.profiles = profiles
    def __init__(self,
                 available=None,
                 free=None,
                 total=None,
                 used=None,
                 local_vars_configuration=None):  # noqa: E501
        """StorageCapacityAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._available = None
        self._free = None
        self._total = None
        self._used = None
        self.discriminator = None

        if available is not None:
            self.available = available
        if free is not None:
            self.free = free
        if total is not None:
            self.total = total
        if used is not None:
            self.used = used
Esempio n. 20
0
    def __init__(self,
                 entity_data=None,
                 entity_moid=None,
                 entity_name=None,
                 entity_type=None,
                 local_vars_configuration=None):  # noqa: E501
        """PolicyConfigResultContextAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._entity_data = None
        self._entity_moid = None
        self._entity_name = None
        self._entity_type = None
        self.discriminator = None

        if entity_data is not None:
            self.entity_data = entity_data
        if entity_moid is not None:
            self.entity_moid = entity_moid
        if entity_name is not None:
            self.entity_name = entity_name
        if entity_type is not None:
            self.entity_type = entity_type
Esempio n. 21
0
    def __init__(self,
                 created=None,
                 serial=None,
                 source=None,
                 registered_device=None,
                 local_vars_configuration=None):  # noqa: E501
        """StoragePureVolumeAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created = None
        self._serial = None
        self._source = None
        self._registered_device = None
        self.discriminator = None

        if created is not None:
            self.created = created
        if serial is not None:
            self.serial = serial
        if source is not None:
            self.source = source
        if registered_device is not None:
            self.registered_device = registered_device
Esempio n. 22
0
    def __init__(self,
                 download_url=None,
                 part_size=None,
                 upload_id=None,
                 upload_url=None,
                 upload_urls=None,
                 local_vars_configuration=None):  # noqa: E501
        """SoftwarerepositoryLocalMachineAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._download_url = None
        self._part_size = None
        self._upload_id = None
        self._upload_url = None
        self._upload_urls = None
        self.discriminator = None

        if download_url is not None:
            self.download_url = download_url
        if part_size is not None:
            self.part_size = part_size
        if upload_id is not None:
            self.upload_id = upload_id
        if upload_url is not None:
            self.upload_url = upload_url
        if upload_urls is not None:
            self.upload_urls = upload_urls
    def __init__(self,
                 host_group_name=None,
                 shared=None,
                 host_group=None,
                 registered_device=None,
                 local_vars_configuration=None):  # noqa: E501
        """StoragePureHostLunAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._host_group_name = None
        self._shared = None
        self._host_group = None
        self._registered_device = None
        self.discriminator = None

        if host_group_name is not None:
            self.host_group_name = host_group_name
        if shared is not None:
            self.shared = shared
        if host_group is not None:
            self.host_group = host_group
        if registered_device is not None:
            self.registered_device = registered_device
    def __init__(self,
                 config_progress=None,
                 duration=None,
                 start_time=None,
                 cluster_profile=None,
                 result_entries=None,
                 local_vars_configuration=None):  # noqa: E501
        """HyperflexConfigResultAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._config_progress = None
        self._duration = None
        self._start_time = None
        self._cluster_profile = None
        self._result_entries = None
        self.discriminator = None

        if config_progress is not None:
            self.config_progress = config_progress
        if duration is not None:
            self.duration = duration
        if start_time is not None:
            self.start_time = start_time
        if cluster_profile is not None:
            self.cluster_profile = cluster_profile
        if result_entries is not None:
            self.result_entries = result_entries
Esempio n. 25
0
    def __init__(self,
                 pid=None,
                 serial_number=None,
                 signature=None,
                 status='DeviceStatusUnknown',
                 sudi_certificate=None,
                 local_vars_configuration=None):  # noqa: E501
        """AssetSudiInfoAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._pid = None
        self._serial_number = None
        self._signature = None
        self._status = None
        self._sudi_certificate = None
        self.discriminator = None

        if pid is not None:
            self.pid = pid
        if serial_number is not None:
            self.serial_number = serial_number
        if signature is not None:
            self.signature = signature
        if status is not None:
            self.status = status
        if sudi_certificate is not None:
            self.sudi_certificate = sudi_certificate
    def __init__(self,
                 enclosure_id=None,
                 fanmodules=None,
                 psus=None,
                 registered_device=None,
                 slots=None,
                 local_vars_configuration=None):  # noqa: E501
        """EquipmentRackEnclosureAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._enclosure_id = None
        self._fanmodules = None
        self._psus = None
        self._registered_device = None
        self._slots = None
        self.discriminator = None

        if enclosure_id is not None:
            self.enclosure_id = enclosure_id
        if fanmodules is not None:
            self.fanmodules = fanmodules
        if psus is not None:
            self.psus = psus
        if registered_device is not None:
            self.registered_device = registered_device
        if slots is not None:
            self.slots = slots
    def __init__(self,
                 bill_to=None,
                 bill_to_global_ultimate=None,
                 contract_number=None,
                 line_status=None,
                 local_vars_configuration=None):  # noqa: E501
        """AssetContractInformationAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._bill_to = None
        self._bill_to_global_ultimate = None
        self._contract_number = None
        self._line_status = None
        self.discriminator = None

        if bill_to is not None:
            self.bill_to = bill_to
        if bill_to_global_ultimate is not None:
            self.bill_to_global_ultimate = bill_to_global_ultimate
        if contract_number is not None:
            self.contract_number = contract_number
        if line_status is not None:
            self.line_status = line_status
    def __init__(self,
                 enabled=None,
                 backup_config=None,
                 config_result=None,
                 device_id=None,
                 organization=None,
                 schedule_config=None,
                 local_vars_configuration=None):  # noqa: E501
        """RecoveryBackupProfileAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._enabled = None
        self._backup_config = None
        self._config_result = None
        self._device_id = None
        self._organization = None
        self._schedule_config = None
        self.discriminator = None

        if enabled is not None:
            self.enabled = enabled
        if backup_config is not None:
            self.backup_config = backup_config
        if config_result is not None:
            self.config_result = config_result
        if device_id is not None:
            self.device_id = device_id
        if organization is not None:
            self.organization = organization
        if schedule_config is not None:
            self.schedule_config = schedule_config
    def __init__(self,
                 changes=None,
                 config_change_context=None,
                 config_change_flag='Pending-changes',
                 disruptions=None,
                 message=None,
                 mod_status='None',
                 local_vars_configuration=None):  # noqa: E501
        """PolicyAbstractConfigChangeDetailAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._changes = None
        self._config_change_context = None
        self._config_change_flag = None
        self._disruptions = None
        self._message = None
        self._mod_status = None
        self.discriminator = None

        if changes is not None:
            self.changes = changes
        if config_change_context is not None:
            self.config_change_context = config_change_context
        if config_change_flag is not None:
            self.config_change_flag = config_change_flag
        if disruptions is not None:
            self.disruptions = disruptions
        self.message = message
        if mod_status is not None:
            self.mod_status = mod_status
    def __init__(self,
                 description=None,
                 name=None,
                 type='',
                 system=None,
                 local_vars_configuration=None):  # noqa: E501
        """IamEndPointPrivilegeAllOf - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._description = None
        self._name = None
        self._type = None
        self._system = None
        self.discriminator = None

        if description is not None:
            self.description = description
        if name is not None:
            self.name = name
        if type is not None:
            self.type = type
        if system is not None:
            self.system = system