# -*- coding: utf-8 -*-
"""Python API object representation of the Tanium SOAP API.
Each of these objects is dynamically generated from the Tanium SOAP API WSDL.
* Generated on: 2017-02-16 at 22:40:32 UTC
* Generated from WSDL file: console-7.0.314.6350.wsdl
* Generated by script: build_soul.py v1.0.0
* Generated using Python version: 2.7.10 (default, Jul 30 2016, 19:40:32) [GCC 4.2.1 Compatible Apple LLVM 8.0.0 (clang-800.0.34)]
* Generated using OS: Darwin-16.4.0-x86_64-i386-64bit
* WSDL version: 0.0.1
* Tanium Platform version: 7.0.314.6350
"""
from __future__ import absolute_import, division, print_function, unicode_literals
import sys
from . import models
IS_PY2 = sys.version_info[0] == 2
STR = unicode if IS_PY2 else str # noqa
[docs]class SensorQueryList(models.ListObject):
"""Tanium SOAP XML element ``sensor_query_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
query : :obj:`list` of :obj:`SensorQuery`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="sensor_query_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="query" type="sensor_query" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "sensor_query_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "query"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = SensorQuery
"""The type of members that should be found in _LIST_ATTR."""
self.query = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class SensorSubcolumnList(models.ListObject):
"""Tanium SOAP XML element ``sensor_subcolumn_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
subcolumn : :obj:`list` of :obj:`SensorSubcolumn`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="sensor_subcolumn_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="subcolumn" type="sensor_subcolumn" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "sensor_subcolumn_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "subcolumn"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = SensorSubcolumn
"""The type of members that should be found in _LIST_ATTR."""
self.subcolumn = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class StringHintList(models.ListObject):
"""Tanium SOAP XML element ``string_hint_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
string_hint : :obj:`list` of :obj:`STR`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="string_hint_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="string_hint" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "string_hint_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "string_hint"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = STR
"""The type of members that should be found in _LIST_ATTR."""
self.string_hint = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class SensorList(models.ListObject):
"""Tanium SOAP XML element ``sensor_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
sensor : :obj:`list` of :obj:`Sensor`
* Attribute that holds the Python list for this ListType.
cache_info : :obj:`CacheInfo`
* Complex attribute that holds a tanium_soul object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="sensor_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="sensor" type="sensor" />
<xsd:element minOccurs="0" name="cache_info" type="cache_info" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "sensor_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "sensor"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = Sensor
"""The type of members that should be found in _LIST_ATTR."""
self.sensor = []
"""List attribute for this object."""
self.cache_info = None
"""Complex property that should contain a tanium_soul object type :obj:`CacheInfo`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["cache_info"] = CacheInfo
models.ListObject.__init__(self, **kwargs)
[docs]class SavedActionApprovalList(models.ListObject):
"""Tanium SOAP XML element ``saved_action_approval_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
saved_action_approval : :obj:`list` of :obj:`SavedActionApproval`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="saved_action_approval_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="saved_action_approval" type="saved_action_approval" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "saved_action_approval_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "saved_action_approval"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = SavedActionApproval
"""The type of members that should be found in _LIST_ATTR."""
self.saved_action_approval = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class SavedActionRowIdList(models.ListObject):
"""Tanium SOAP XML element ``saved_action_row_id_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
row_id : :obj:`list` of :obj:`int`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="saved_action_row_id_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="row_id" type="xsd:long" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "saved_action_row_id_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "row_id"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = int
"""The type of members that should be found in _LIST_ATTR."""
self.row_id = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class SavedActionList(models.ListObject):
"""Tanium SOAP XML element ``saved_action_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
saved_action : :obj:`list` of :obj:`SavedAction`
* Attribute that holds the Python list for this ListType.
cache_info : :obj:`CacheInfo`
* Complex attribute that holds a tanium_soul object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="saved_action_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="saved_action" type="saved_action" />
<xsd:element minOccurs="0" name="cache_info" type="cache_info" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "saved_action_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "saved_action"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = SavedAction
"""The type of members that should be found in _LIST_ATTR."""
self.saved_action = []
"""List attribute for this object."""
self.cache_info = None
"""Complex property that should contain a tanium_soul object type :obj:`CacheInfo`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["cache_info"] = CacheInfo
models.ListObject.__init__(self, **kwargs)
[docs]class GroupList(models.ListObject):
"""Tanium SOAP XML element ``group_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
group : :obj:`list` of :obj:`Group`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="group_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="group" type="group" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "group_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "group"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = Group
"""The type of members that should be found in _LIST_ATTR."""
self.group = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class FilterList(models.ListObject):
"""Tanium SOAP XML element ``filter_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
filter : :obj:`list` of :obj:`Filter`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="filter_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="filter" type="filter" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "filter_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "filter"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = Filter
"""The type of members that should be found in _LIST_ATTR."""
self.filter = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class SelectList(models.ListObject):
"""Tanium SOAP XML element ``select_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
select : :obj:`list` of :obj:`Select`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="select_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="select" type="select" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "select_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "select"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = Select
"""The type of members that should be found in _LIST_ATTR."""
self.select = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class ErrorList(models.ListObject):
"""Tanium SOAP XML element ``error_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
error : :obj:`list` of :obj:`XmlError`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="error_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="error" type="xml_error" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "error_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "error"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = XmlError
"""The type of members that should be found in _LIST_ATTR."""
self.error = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class QuestionList(models.ListObject):
"""Tanium SOAP XML element ``question_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
question : :obj:`list` of :obj:`Question`
* Attribute that holds the Python list for this ListType.
info : :obj:`QuestionListInfo`
* Complex attribute that holds a tanium_soul object type.
cache_info : :obj:`CacheInfo`
* Complex attribute that holds a tanium_soul object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="question_list">
<xsd:sequence>
<xsd:element minOccurs="0" name="info" type="question_list_info" />
<xsd:element maxOccurs="unbounded" minOccurs="0" name="question" type="question" />
<xsd:element minOccurs="0" name="cache_info" type="cache_info" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "question_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "question"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = Question
"""The type of members that should be found in _LIST_ATTR."""
self.question = []
"""List attribute for this object."""
self.info = None
"""Complex property that should contain a tanium_soul object type :obj:`QuestionListInfo`."""
self.cache_info = None
"""Complex property that should contain a tanium_soul object type :obj:`CacheInfo`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["info"] = QuestionListInfo
self._COMPLEX["cache_info"] = CacheInfo
models.ListObject.__init__(self, **kwargs)
[docs]class PackageFileTemplateList(models.ListObject):
"""Tanium SOAP XML element ``package_file_template_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
file_template : :obj:`list` of :obj:`PackageFileTemplate`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="package_file_template_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="file_template" type="package_file_template" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "package_file_template_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "file_template"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = PackageFileTemplate
"""The type of members that should be found in _LIST_ATTR."""
self.file_template = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class PackageFileStatusList(models.ListObject):
"""Tanium SOAP XML element ``package_file_status_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
status : :obj:`list` of :obj:`PackageFileStatus`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="package_file_status_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="status" type="package_file_status" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "package_file_status_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "status"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = PackageFileStatus
"""The type of members that should be found in _LIST_ATTR."""
self.status = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class PackageFileList(models.ListObject):
"""Tanium SOAP XML element ``package_file_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
file : :obj:`list` of :obj:`PackageFile`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="package_file_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="file" type="package_file" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "package_file_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "file"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = PackageFile
"""The type of members that should be found in _LIST_ATTR."""
self.file = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class PackageSpecList(models.ListObject):
"""Tanium SOAP XML element ``package_spec_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
package_spec : :obj:`list` of :obj:`PackageSpec`
* Attribute that holds the Python list for this ListType.
cache_info : :obj:`CacheInfo`
* Complex attribute that holds a tanium_soul object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="package_spec_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="package_spec" type="package_spec" />
<xsd:element minOccurs="0" name="cache_info" type="cache_info" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "package_spec_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "package_spec"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = PackageSpec
"""The type of members that should be found in _LIST_ATTR."""
self.package_spec = []
"""List attribute for this object."""
self.cache_info = None
"""Complex property that should contain a tanium_soul object type :obj:`CacheInfo`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["cache_info"] = CacheInfo
models.ListObject.__init__(self, **kwargs)
[docs]class WhiteListedUrlList(models.ListObject):
"""Tanium SOAP XML element ``white_listed_url_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
white_listed_url : :obj:`list` of :obj:`WhiteListedUrl`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="white_listed_url_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="white_listed_url" type="white_listed_url" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "white_listed_url_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "white_listed_url"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = WhiteListedUrl
"""The type of members that should be found in _LIST_ATTR."""
self.white_listed_url = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class VersionAggregateList(models.ListObject):
"""Tanium SOAP XML element ``version_aggregate_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
version : :obj:`list` of :obj:`VersionAggregate`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="version_aggregate_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="version" type="version_aggregate" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "version_aggregate_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "version"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = VersionAggregate
"""The type of members that should be found in _LIST_ATTR."""
self.version = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class SystemStatusList(models.ListObject):
"""Tanium SOAP XML element ``system_status_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
client_status : :obj:`list` of :obj:`ClientStatus`
* Attribute that holds the Python list for this ListType.
aggregate : :obj:`SystemStatusAggregate`
* Complex attribute that holds a tanium_soul object type.
cache_info : :obj:`CacheInfo`
* Complex attribute that holds a tanium_soul object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="system_status_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="client_status" type="client_status" />
<xsd:element minOccurs="0" name="aggregate" type="system_status_aggregate" />
<xsd:element minOccurs="0" name="cache_info" type="cache_info" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "system_status_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "client_status"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = ClientStatus
"""The type of members that should be found in _LIST_ATTR."""
self.client_status = []
"""List attribute for this object."""
self.aggregate = None
"""Complex property that should contain a tanium_soul object type :obj:`SystemStatusAggregate`."""
self.cache_info = None
"""Complex property that should contain a tanium_soul object type :obj:`CacheInfo`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["aggregate"] = SystemStatusAggregate
self._COMPLEX["cache_info"] = CacheInfo
models.ListObject.__init__(self, **kwargs)
[docs]class SystemSettingList(models.ListObject):
"""Tanium SOAP XML element ``system_setting_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
system_setting : :obj:`list` of :obj:`SystemSetting`
* Attribute that holds the Python list for this ListType.
cache_info : :obj:`CacheInfo`
* Complex attribute that holds a tanium_soul object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="system_setting_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="system_setting" type="system_setting" />
<xsd:element minOccurs="0" name="cache_info" type="cache_info" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "system_setting_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "system_setting"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = SystemSetting
"""The type of members that should be found in _LIST_ATTR."""
self.system_setting = []
"""List attribute for this object."""
self.cache_info = None
"""Complex property that should contain a tanium_soul object type :obj:`CacheInfo`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["cache_info"] = CacheInfo
models.ListObject.__init__(self, **kwargs)
[docs]class UserList(models.ListObject):
"""Tanium SOAP XML element ``user_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
user : :obj:`list` of :obj:`User`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="user_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="user" type="user" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "user_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "user"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = User
"""The type of members that should be found in _LIST_ATTR."""
self.user = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class PermissionList(models.ListObject):
"""Tanium SOAP XML element ``permission_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
permission : :obj:`list` of :obj:`STR`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:empty_prefix2="urn:TaniumSOAP" xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="permission_list">
<xsd:annotation>
<xsd:appinfo>
<empty_prefix2:constants>
<empty_prefix2:constant>
<empty_prefix2:name>ADMIN</empty_prefix2:name>
<empty_prefix2:value type="xsd:string">admin</empty_prefix2:value>
</empty_prefix2:constant>
<empty_prefix2:constant>
<empty_prefix2:name>QUESTION_READ</empty_prefix2:name>
<empty_prefix2:value type="xsd:string">question_read</empty_prefix2:value>
</empty_prefix2:constant>
<empty_prefix2:constant>
<empty_prefix2:name>QUESTION_WRITE</empty_prefix2:name>
<empty_prefix2:value type="xsd:string">question_write</empty_prefix2:value>
</empty_prefix2:constant>
<empty_prefix2:constant>
<empty_prefix2:name>SENSOR_READ</empty_prefix2:name>
<empty_prefix2:value type="xsd:string">sensor_read</empty_prefix2:value>
</empty_prefix2:constant>
<empty_prefix2:constant>
<empty_prefix2:name>SENSOR_WRITE</empty_prefix2:name>
<empty_prefix2:value type="xsd:string">sensor_write</empty_prefix2:value>
</empty_prefix2:constant>
<empty_prefix2:constant>
<empty_prefix2:name>ACTION_READ</empty_prefix2:name>
<empty_prefix2:value type="xsd:string">action_read</empty_prefix2:value>
</empty_prefix2:constant>
<empty_prefix2:constant>
<empty_prefix2:name>ACTION_WRITE</empty_prefix2:name>
<empty_prefix2:value type="xsd:string">action_write</empty_prefix2:value>
</empty_prefix2:constant>
<empty_prefix2:constant>
<empty_prefix2:name>ACTION_APPROVE</empty_prefix2:name>
<empty_prefix2:value type="xsd:string">action_approval</empty_prefix2:value>
</empty_prefix2:constant>
<empty_prefix2:constant>
<empty_prefix2:name>NOTIFICATION_WRITE</empty_prefix2:name>
<empty_prefix2:value type="xsd:string">notification_write</empty_prefix2:value>
</empty_prefix2:constant>
<empty_prefix2:constant>
<empty_prefix2:name>CLIENTS_READ</empty_prefix2:name>
<empty_prefix2:value type="xsd:string">clients_read</empty_prefix2:value>
</empty_prefix2:constant>
<empty_prefix2:constant>
<empty_prefix2:name>QUESTION_LOG_READ</empty_prefix2:name>
<empty_prefix2:value type="xsd:string">question_log_read</empty_prefix2:value>
</empty_prefix2:constant>
<empty_prefix2:constant>
<empty_prefix2:name>CONTENT_ADMIN</empty_prefix2:name>
<empty_prefix2:value type="xsd:string">content_admin</empty_prefix2:value>
</empty_prefix2:constant>
</empty_prefix2:constants>
</xsd:appinfo>
</xsd:annotation>
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="permission" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
{"name": "ADMIN", "value": "admin", "value_type": STR},
{"name": "QUESTION_READ", "value": "question_read", "value_type": STR},
{"name": "QUESTION_WRITE", "value": "question_write", "value_type": STR},
{"name": "SENSOR_READ", "value": "sensor_read", "value_type": STR},
{"name": "SENSOR_WRITE", "value": "sensor_write", "value_type": STR},
{"name": "ACTION_READ", "value": "action_read", "value_type": STR},
{"name": "ACTION_WRITE", "value": "action_write", "value_type": STR},
{"name": "ACTION_APPROVE", "value": "action_approval", "value_type": STR},
{"name": "NOTIFICATION_WRITE", "value": "notification_write", "value_type": STR},
{"name": "CLIENTS_READ", "value": "clients_read", "value_type": STR},
{"name": "QUESTION_LOG_READ", "value": "question_log_read", "value_type": STR},
{"name": "CONTENT_ADMIN", "value": "content_admin", "value_type": STR},
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "permission_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "permission"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = STR
"""The type of members that should be found in _LIST_ATTR."""
self.permission = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class UserRoleList(models.ListObject):
"""Tanium SOAP XML element ``user_role_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
role : :obj:`list` of :obj:`UserRole`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="user_role_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="role" type="user_role" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "user_role_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "role"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = UserRole
"""The type of members that should be found in _LIST_ATTR."""
self.role = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class ActionList(models.ListObject):
"""Tanium SOAP XML element ``action_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
action : :obj:`list` of :obj:`Action`
* Attribute that holds the Python list for this ListType.
info : :obj:`ActionListInfo`
* Complex attribute that holds a tanium_soul object type.
cache_info : :obj:`CacheInfo`
* Complex attribute that holds a tanium_soul object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="action_list">
<xsd:sequence>
<xsd:element minOccurs="0" name="info" type="action_list_info" />
<xsd:element maxOccurs="unbounded" minOccurs="0" name="action" type="action" />
<xsd:element minOccurs="0" name="cache_info" type="cache_info" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "action_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "action"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = Action
"""The type of members that should be found in _LIST_ATTR."""
self.action = []
"""List attribute for this object."""
self.info = None
"""Complex property that should contain a tanium_soul object type :obj:`ActionListInfo`."""
self.cache_info = None
"""Complex property that should contain a tanium_soul object type :obj:`CacheInfo`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["info"] = ActionListInfo
self._COMPLEX["cache_info"] = CacheInfo
models.ListObject.__init__(self, **kwargs)
[docs]class ActionStopList(models.ListObject):
"""Tanium SOAP XML element ``action_stop_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
action_stop : :obj:`list` of :obj:`ActionStop`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="action_stop_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="action_stop" type="action_stop" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "action_stop_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "action_stop"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = ActionStop
"""The type of members that should be found in _LIST_ATTR."""
self.action_stop = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class ArchivedQuestionList(models.ListObject):
"""Tanium SOAP XML element ``archived_question_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
archived_question : :obj:`list` of :obj:`ArchivedQuestion`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="archived_question_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="archived_question" type="archived_question" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "archived_question_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "archived_question"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = ArchivedQuestion
"""The type of members that should be found in _LIST_ATTR."""
self.archived_question = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class SavedQuestionList(models.ListObject):
"""Tanium SOAP XML element ``saved_question_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
saved_question : :obj:`list` of :obj:`SavedQuestion`
* Attribute that holds the Python list for this ListType.
cache_info : :obj:`CacheInfo`
* Complex attribute that holds a tanium_soul object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="saved_question_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="saved_question" type="saved_question" />
<xsd:element minOccurs="0" name="cache_info" type="cache_info" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "saved_question_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "saved_question"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = SavedQuestion
"""The type of members that should be found in _LIST_ATTR."""
self.saved_question = []
"""List attribute for this object."""
self.cache_info = None
"""Complex property that should contain a tanium_soul object type :obj:`CacheInfo`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["cache_info"] = CacheInfo
models.ListObject.__init__(self, **kwargs)
[docs]class ParseJobList(models.ListObject):
"""Tanium SOAP XML element ``parse_job_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
parse_job : :obj:`list` of :obj:`ParseJob`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="parse_job_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="parse_job" type="parse_job" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "parse_job_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "parse_job"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = ParseJob
"""The type of members that should be found in _LIST_ATTR."""
self.parse_job = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class ParseResultGroupList(models.ListObject):
"""Tanium SOAP XML element ``parse_result_group_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
parse_result_group : :obj:`list` of :obj:`ParseResultGroup`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="parse_result_group_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="parse_result_group" type="parse_result_group" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "parse_result_group_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "parse_result_group"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = ParseResultGroup
"""The type of members that should be found in _LIST_ATTR."""
self.parse_result_group = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class ParseResultList(models.ListObject):
"""Tanium SOAP XML element ``parse_result_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
parse_result : :obj:`list` of :obj:`ParseResult`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="parse_result_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="parse_result" type="parse_result" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "parse_result_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "parse_result"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = ParseResult
"""The type of members that should be found in _LIST_ATTR."""
self.parse_result = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class ParameterList(models.ListObject):
"""Tanium SOAP XML element ``parameter_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
parameter : :obj:`list` of :obj:`Parameter`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="parameter_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="parameter" type="parameter" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "parameter_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "parameter"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = Parameter
"""The type of members that should be found in _LIST_ATTR."""
self.parameter = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class PluginArgumentList(models.ListObject):
"""Tanium SOAP XML element ``plugin_argument_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
argument : :obj:`list` of :obj:`PluginArgument`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="plugin_argument_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="argument" type="plugin_argument" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "plugin_argument_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "argument"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = PluginArgument
"""The type of members that should be found in _LIST_ATTR."""
self.argument = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class PluginSqlResultList(models.ListObject):
"""Tanium SOAP XML element ``plugin_sql_result_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
value : :obj:`list` of :obj:`STR`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="plugin_sql_result_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="value" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "plugin_sql_result_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "value"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = STR
"""The type of members that should be found in _LIST_ATTR."""
self.value = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class PluginSqlColumnList(models.ListObject):
"""Tanium SOAP XML element ``plugin_sql_column_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
name : :obj:`list` of :obj:`STR`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="plugin_sql_column_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="name" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "plugin_sql_column_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "name"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = STR
"""The type of members that should be found in _LIST_ATTR."""
self.name = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class PluginSql(models.ListObject):
"""Tanium SOAP XML element ``plugin_sql`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
result_row : :obj:`list` of :obj:`PluginSqlResultList`
* Attribute that holds the Python list for this ListType.
rows_affected : :obj:`int`
* Simple attribute that holds a python internal object type.
result_count : :obj:`int`
* Simple attribute that holds a python internal object type.
columns : :obj:`PluginSqlColumnList`
* Complex attribute that holds a tanium_soul object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="plugin_sql">
<xsd:sequence>
<xsd:element name="columns" type="plugin_sql_column_list" />
<xsd:element maxOccurs="unbounded" name="result_row" type="plugin_sql_result_list" />
<xsd:element minOccurs="0" name="rows_affected" type="xsd:long" />
<xsd:element minOccurs="0" name="result_count" type="xsd:long" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "plugin_sql"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "result_row"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = PluginSqlResultList
"""The type of members that should be found in _LIST_ATTR."""
self.result_row = []
"""List attribute for this object."""
self.rows_affected = None
"""Simple property that should contain a python object type :obj:`int`."""
self.result_count = None
"""Simple property that should contain a python object type :obj:`int`."""
self.columns = None
"""Complex property that should contain a tanium_soul object type :obj:`PluginSqlColumnList`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
self._SIMPLE["rows_affected"] = int
self._SIMPLE["result_count"] = int
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["columns"] = PluginSqlColumnList
models.ListObject.__init__(self, **kwargs)
[docs]class PluginCommandList(models.ListObject):
"""Tanium SOAP XML element ``plugin_command_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
command : :obj:`list` of :obj:`STR`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="plugin_command_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="command" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "plugin_command_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "command"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = STR
"""The type of members that should be found in _LIST_ATTR."""
self.command = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class UploadFileList(models.ListObject):
"""Tanium SOAP XML element ``upload_file_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
upload_file : :obj:`list` of :obj:`UploadFile`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="upload_file_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="upload_file" type="upload_file" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "upload_file_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "upload_file"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = UploadFile
"""The type of members that should be found in _LIST_ATTR."""
self.upload_file = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class PluginList(models.ListObject):
"""Tanium SOAP XML element ``plugin_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
plugin : :obj:`list` of :obj:`Plugin`
* Attribute that holds the Python list for this ListType.
cache_info : :obj:`CacheInfo`
* Complex attribute that holds a tanium_soul object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="plugin_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="plugin" type="plugin" />
<xsd:element minOccurs="0" name="cache_info" type="cache_info" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "plugin_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "plugin"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = Plugin
"""The type of members that should be found in _LIST_ATTR."""
self.plugin = []
"""List attribute for this object."""
self.cache_info = None
"""Complex property that should contain a tanium_soul object type :obj:`CacheInfo`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["cache_info"] = CacheInfo
models.ListObject.__init__(self, **kwargs)
[docs]class PluginScheduleList(models.ListObject):
"""Tanium SOAP XML element ``plugin_schedule_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
plugin_schedule : :obj:`list` of :obj:`PluginSchedule`
* Attribute that holds the Python list for this ListType.
cache_info : :obj:`CacheInfo`
* Complex attribute that holds a tanium_soul object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="plugin_schedule_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="plugin_schedule" type="plugin_schedule" />
<xsd:element minOccurs="0" name="cache_info" type="cache_info" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "plugin_schedule_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "plugin_schedule"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = PluginSchedule
"""The type of members that should be found in _LIST_ATTR."""
self.plugin_schedule = []
"""List attribute for this object."""
self.cache_info = None
"""Complex property that should contain a tanium_soul object type :obj:`CacheInfo`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["cache_info"] = CacheInfo
models.ListObject.__init__(self, **kwargs)
[docs]class ComputerSpecList(models.ListObject):
"""Tanium SOAP XML element ``computer_spec_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
computer_spec : :obj:`list` of :obj:`ComputerGroupSpec`
* Attribute that holds the Python list for this ListType.
cache_info : :obj:`CacheInfo`
* Complex attribute that holds a tanium_soul object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="computer_spec_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="computer_spec" type="computer_group_spec" />
<xsd:element minOccurs="0" name="cache_info" type="cache_info" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "computer_spec_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "computer_spec"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = ComputerGroupSpec
"""The type of members that should be found in _LIST_ATTR."""
self.computer_spec = []
"""List attribute for this object."""
self.cache_info = None
"""Complex property that should contain a tanium_soul object type :obj:`CacheInfo`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["cache_info"] = CacheInfo
models.ListObject.__init__(self, **kwargs)
[docs]class ComputerGroupList(models.ListObject):
"""Tanium SOAP XML element ``computer_group_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
computer_group : :obj:`list` of :obj:`ComputerGroup`
* Attribute that holds the Python list for this ListType.
cache_info : :obj:`CacheInfo`
* Complex attribute that holds a tanium_soul object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="computer_group_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="computer_group" type="computer_group" />
<xsd:element minOccurs="0" name="cache_info" type="cache_info" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "computer_group_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "computer_group"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = ComputerGroup
"""The type of members that should be found in _LIST_ATTR."""
self.computer_group = []
"""List attribute for this object."""
self.cache_info = None
"""Complex property that should contain a tanium_soul object type :obj:`CacheInfo`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["cache_info"] = CacheInfo
models.ListObject.__init__(self, **kwargs)
[docs]class CacheFilterList(models.ListObject):
"""Tanium SOAP XML element ``cache_filter_list`` Python object.
This object type behaves like a Python list type, and uses ``_LIST_ATTR`` to store the actual list.
Attributes
----------
filter : :obj:`list` of :obj:`CacheFilter`
* Attribute that holds the Python list for this ListType.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="cache_filter_list">
<xsd:sequence>
<xsd:element maxOccurs="unbounded" minOccurs="0" name="filter" type="cache_filter" />
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "cache_filter_list"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self._LIST_ATTR = "filter"
"""The attribute that stores the actual list object."""
self._LIST_TYPE = CacheFilter
"""The type of members that should be found in _LIST_ATTR."""
self.filter = []
"""List attribute for this object."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.ListObject.__init__(self, **kwargs)
[docs]class SensorQuery(models.BasicObject):
"""Tanium SOAP XML element ``sensor_query`` Python object.
This is a regular Python object.
Attributes
----------
platform : :obj:`STR`
* Simple attribute that holds a python internal object type.
script : :obj:`STR`
* Simple attribute that holds a python internal object type.
script_type : :obj:`STR`
* Simple attribute that holds a python internal object type.
signature : :obj:`STR`
* Simple attribute that holds a python internal object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="sensor_query">
<xsd:all>
<xsd:element minOccurs="0" name="platform" type="xsd:string" />
<!-- Windows, Linux, Solaris, AIX or Mac. Defaults to Windows. -->
<xsd:element minOccurs="0" name="script" type="xsd:string" />
<!-- The script that will be executed on the client -->
<!--
The script_type specifies how the script will be executed.
WMIQuery: execute the script as a WMI Query
BESRelevance: execute the script as a BigFix Relevance expression (using QNA)
VBScript: execute the script as a VB Script (if platform is Windows then this is the default)
Powershell: execute the script using PowerShell
JScript: execute the script using JScript (Windows platform only)
- Enable UI support with global setting "enable_python_jscript_type_flag"
Python: execute the script using Python (all platforms but it requires separate dll/.so files to be distributed to the endpoints).
- Enable UI support with global setting "enable_python_jscript_type_flag"
UnixShell: execute the script as a shell script, use #! notation to specify a specific shell program, otherwise /bin/sh will be used (if platform is Linux, Solaris, AIX, or Mac, then this is the default).
-->
<xsd:element minOccurs="0" name="script_type" type="xsd:string" />
<xsd:element minOccurs="0" name="signature" type="xsd:string" />
<!-- A value that will be verified if the server license requires signed content -->
</xsd:all>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "sensor_query"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self.platform = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.script = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.script_type = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.signature = None
"""Simple property that should contain a python object type :obj:`STR`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
self._SIMPLE["platform"] = STR
self._SIMPLE["script"] = STR
self._SIMPLE["script_type"] = STR
self._SIMPLE["signature"] = STR
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.BasicObject.__init__(self, **kwargs)
[docs]class SensorSubcolumn(models.BasicObject):
"""Tanium SOAP XML element ``sensor_subcolumn`` Python object.
This is a regular Python object.
Attributes
----------
name : :obj:`STR`
* Simple attribute that holds a python internal object type.
index : :obj:`int`
* Simple attribute that holds a python internal object type.
value_type : :obj:`STR`
* Simple attribute that holds a python internal object type.
ignore_case_flag : :obj:`int`
* Simple attribute that holds a python internal object type.
hidden_flag : :obj:`int`
* Simple attribute that holds a python internal object type.
exclude_from_parse_flag : :obj:`int`
* Simple attribute that holds a python internal object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="sensor_subcolumn">
<xsd:all>
<xsd:element minOccurs="0" name="name" type="xsd:string" />
<xsd:element minOccurs="0" name="index" type="xsd:int" />
<!-- The index into to the delimited sensor data represented by this column -->
<!--
The value_type specifies how the values are compared.
String: standard lexicographical comparison (the default)
Version: values are expected to be version strings, e.g. 9.4.2 is less than 10.1.3
Numeric: numeric comparison, including decimal, floating point, and scientific notation
BESDate: values are expected to be valid BES date strings
IPAddress: values are expected to be IP addresses
WMIDate: values are expected to be valid WMI date strings
TimeDiff: values are expected to be an expression of an amount of time, e.g. "2 years, 3 months, 18 days, 4 hours, 22 minutes, and 3.67 seconds" or "4.2 hours" (numeric + "Y|MO|W|D|H|M|S" units)
DataSize: values are expected to be an expression of an amount of data, e.g. 125MB or 23K or 34.2Gig (numeric + B|K|M|G|T units)
NumericInteger: values are expected to be integer numeric values
-->
<xsd:element minOccurs="0" name="value_type" type="xsd:string" />
<xsd:element minOccurs="0" name="ignore_case_flag" type="xsd:int" />
<!-- note that unlike most flags, this defaults to true which means case is ignored by default -->
<xsd:element minOccurs="0" name="hidden_flag" type="xsd:int" />
<!-- if set, then this is an "internal" object that should not be shown to end users -->
<!-- tags below this line are Not Yet Implemented: -->
<xsd:element minOccurs="0" name="exclude_from_parse_flag" type="xsd:int" />
<!-- if true, then the string results of this subcolumn will not be matched by the natural language parser -->
</xsd:all>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "sensor_subcolumn"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self.name = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.index = None
"""Simple property that should contain a python object type :obj:`int`."""
self.value_type = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.ignore_case_flag = None
"""Simple property that should contain a python object type :obj:`int`."""
self.hidden_flag = None
"""Simple property that should contain a python object type :obj:`int`."""
self.exclude_from_parse_flag = None
"""Simple property that should contain a python object type :obj:`int`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
self._SIMPLE["name"] = STR
self._SIMPLE["index"] = int
self._SIMPLE["value_type"] = STR
self._SIMPLE["ignore_case_flag"] = int
self._SIMPLE["hidden_flag"] = int
self._SIMPLE["exclude_from_parse_flag"] = int
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.BasicObject.__init__(self, **kwargs)
[docs]class SavedActionPolicy(models.BasicObject):
"""Tanium SOAP XML element ``saved_action_policy`` Python object.
This is a regular Python object.
Attributes
----------
saved_question_id : :obj:`int`
* Simple attribute that holds a python internal object type.
saved_question_group_id : :obj:`int`
* Simple attribute that holds a python internal object type.
row_filter_group_id : :obj:`int`
* Simple attribute that holds a python internal object type.
max_age : :obj:`int`
* Simple attribute that holds a python internal object type.
min_count : :obj:`int`
* Simple attribute that holds a python internal object type.
saved_question_group : :obj:`Group`
* Complex attribute that holds a tanium_soul object type.
row_filter_group : :obj:`Group`
* Complex attribute that holds a tanium_soul object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="saved_action_policy">
<xsd:all>
<xsd:element minOccurs="0" name="saved_question_id" type="xsd:long" />
<xsd:element minOccurs="0" name="saved_question_group_id" type="xsd:long" />
<!-- deprecated, use saved_question_group instead -->
<xsd:element minOccurs="0" name="saved_question_group" type="group" />
<xsd:element minOccurs="0" name="row_filter_group_id" type="xsd:long" />
<!-- deprecated, use row_filter_group instead -->
<xsd:element minOccurs="0" name="row_filter_group" type="group" />
<xsd:element minOccurs="0" name="max_age" type="xsd:long" />
<!-- defaults to saved_action.issue_seconds -->
<xsd:element minOccurs="0" name="min_count" type="xsd:int" />
<!-- the number of matching machines required to issue the saved_action. Defaults to the global setting policy_default_min_count -->
</xsd:all>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "saved_action_policy"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self.saved_question_id = None
"""Simple property that should contain a python object type :obj:`int`."""
self.saved_question_group_id = None
"""Simple property that should contain a python object type :obj:`int`."""
self.row_filter_group_id = None
"""Simple property that should contain a python object type :obj:`int`."""
self.max_age = None
"""Simple property that should contain a python object type :obj:`int`."""
self.min_count = None
"""Simple property that should contain a python object type :obj:`int`."""
self.saved_question_group = None
"""Complex property that should contain a tanium_soul object type :obj:`Group`."""
self.row_filter_group = None
"""Complex property that should contain a tanium_soul object type :obj:`Group`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
self._SIMPLE["saved_question_id"] = int
self._SIMPLE["saved_question_group_id"] = int
self._SIMPLE["row_filter_group_id"] = int
self._SIMPLE["max_age"] = int
self._SIMPLE["min_count"] = int
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["saved_question_group"] = Group
self._COMPLEX["row_filter_group"] = Group
models.BasicObject.__init__(self, **kwargs)
[docs]class SavedActionApproval(models.BasicObject):
"""Tanium SOAP XML element ``saved_action_approval`` Python object.
This is a regular Python object.
Attributes
----------
id : :obj:`int`
* Simple attribute that holds a python internal object type.
name : :obj:`STR`
* Simple attribute that holds a python internal object type.
owner_user_id : :obj:`int`
* Simple attribute that holds a python internal object type.
approved_flag : :obj:`int`
* Simple attribute that holds a python internal object type.
metadata : :obj:`MetadataList`
* Complex attribute that holds a tanium_soul object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="saved_action_approval">
<!-- For approving actions use AddObject and supply this -->
<xsd:all>
<xsd:element minOccurs="0" name="id" type="xsd:long" />
<!-- ID of the saved action to be approved -->
<xsd:element minOccurs="0" name="name" type="xsd:string" />
<!-- Name of action to be approved. Not needed if ID is supplied -->
<xsd:element minOccurs="0" name="owner_user_id" type="xsd:int" />
<!-- Read-only value: The ID of the user that created the saved action. -->
<xsd:element minOccurs="0" name="approved_flag" type="xsd:int" />
<!-- Is action approved or not? This uses the posting user to supply the approver name and ID. -->
<xsd:element minOccurs="0" name="metadata" type="metadata_list" />
<!-- metadata to be used for approval comments. entries are associated to the saved action being approved -->
</xsd:all>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "saved_action_approval"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self.id = None
"""Simple property that should contain a python object type :obj:`int`."""
self.name = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.owner_user_id = None
"""Simple property that should contain a python object type :obj:`int`."""
self.approved_flag = None
"""Simple property that should contain a python object type :obj:`int`."""
self.metadata = None
"""Complex property that should contain a tanium_soul object type :obj:`MetadataList`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
self._SIMPLE["id"] = int
self._SIMPLE["name"] = STR
self._SIMPLE["owner_user_id"] = int
self._SIMPLE["approved_flag"] = int
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["metadata"] = MetadataList
models.BasicObject.__init__(self, **kwargs)
[docs]class SavedAction(models.BasicObject):
"""Tanium SOAP XML element ``saved_action`` Python object.
This is a regular Python object.

Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="saved_action">
<xsd:all>
<xsd:element minOccurs="0" name="id" type="xsd:long" />
<xsd:element minOccurs="0" name="name" type="xsd:string" />
<xsd:element minOccurs="0" name="comment" type="xsd:string" />
<!-- action comment -->
<xsd:element minOccurs="0" name="status" type="xsd:int" />
<!-- Status of action: Pending/Active/Stopped/Expired -->
<xsd:element minOccurs="0" name="issue_seconds" type="xsd:int" />
<xsd:element minOccurs="0" name="distribute_seconds" type="xsd:int" />
<xsd:element minOccurs="0" name="start_time" type="xsd:string" />
<!-- the date and time when the action became active, empty string or null means "ASAP" -->
<xsd:element minOccurs="0" name="end_time" type="xsd:string" />
<xsd:element minOccurs="0" name="package_spec" type="package_spec" />
<!-- The package deployed by this action -->
<xsd:element minOccurs="0" name="action_group_id" type="xsd:long" />
<!-- deprecated, use action_group instead -->
<xsd:element minOccurs="0" name="action_group" type="group" />
<!-- The parent group of machines to target -->
<xsd:element minOccurs="0" name="target_group" type="group" />
<!-- The group of machines to target -->
<xsd:element minOccurs="0" name="public_flag" type="xsd:int" />
<!-- currently unused -->
<xsd:element minOccurs="0" name="policy_flag" type="xsd:int" />
<!-- flag as to whether or not a policy is being used -->
<xsd:element minOccurs="0" name="policy" type="saved_action_policy" />
<!-- definition of the policy -->
<xsd:element minOccurs="0" name="metadata" type="metadata_list" />
<xsd:element minOccurs="0" name="row_ids" type="saved_action_row_id_list" />
<!-- The following is output only information -->
<xsd:element minOccurs="0" name="expire_seconds" type="xsd:int" />
<!-- how long from the start time before the action expires (value is derived from package) -->
<xsd:element minOccurs="0" name="user" type="user" />
<xsd:element minOccurs="0" name="approved_flag" type="xsd:int" />
<xsd:element minOccurs="0" name="approver" type="user" />
<xsd:element minOccurs="0" name="issue_count" type="xsd:int" />
<xsd:element minOccurs="0" name="creation_time" type="xsd:string" />
<xsd:element minOccurs="0" name="next_start_time" type="xsd:string" />
<xsd:element minOccurs="0" name="last_start_time" type="xsd:string" />
<xsd:element minOccurs="0" name="user_start_time" type="xsd:string" />
<xsd:element minOccurs="0" name="last_action" type="action" />
<xsd:element minOccurs="0" name="cache_row_id" type="xsd:int" />
<!-- ID used as a unqiue identifier in the response cache.
This is a regular Python object.

 The sensor can be specifed by ID, name, or hash -->
<xsd:element minOccurs="0" name="id" type="xsd:long" />
<xsd:element minOccurs="0" name="name" type="xsd:string" />
<xsd:element minOccurs="0" name="hash" type="xsd:long" />
<xsd:element minOccurs="0" name="string_count" type="xsd:long" />
<xsd:element minOccurs="0" name="category" type="xsd:string" />
<xsd:element minOccurs="0" name="description" type="xsd:string" />
<xsd:element minOccurs="0" name="queries" type="sensor_query_list" />
<xsd:element minOccurs="0" name="source_id" type="xsd:int" />
<!-- the id of the sensor into which the parameters are substituted, if specified, source_hash may be omitted -->
<xsd:element minOccurs="0" name="source_hash" type="xsd:int" />
<!-- the hash of the sensor into which the parameters are substituted, if specified, source_id may be omitted -->
<xsd:element minOccurs="0" name="parameters" type="parameter_list" />
<!-- List of parameters to substitute into the source sensor -->
<xsd:element minOccurs="0" name="parameter_definition" type="xsd:string" />
<!--
The value_type specifies how the values are compared.
String: standard lexicographical comparison (the default)
Version: values are expected to be version strings, e.g. 9.4.2 is less than 10.1.3
Numeric: numeric comparison, including decimal, floating point, and scientific notation
BESDate: values are expected to be valid BES date strings
IPAddress: values are expected to be IP addresses
WMIDate: values are expected to be valid WMI date strings
TimeDiff: values are expected to be an expression of an amount of time, e.g. "2 years, 3 months, 18 days, 4 hours, 22 minutes, and 3.67 seconds" or "4.2 hours" (numeric + "Y|MO|W|D|H|M|S" units)
DataSize: values are expected to be an expression of an amount of data, e.g. 125MB or 23K or 34.2Gig (numeric + B|K|M|G|T units)
NumericInteger: values are expected to be integer numeric values
-->
<xsd:element minOccurs="0" name="value_type" type="xsd:string" />
<xsd:element minOccurs="0" name="max_age_seconds" type="xsd:int" />
<!-- how old a sensor result can be before we consider it invalid, when results are half this old, the sensor will be re-evaluated -->
<xsd:element minOccurs="0" name="ignore_case_flag" type="xsd:int" />
<!-- note that unlike most flags, this defaults to true which means case is ignored by default -->
<xsd:element minOccurs="0" name="exclude_from_parse_flag" type="xsd:int" />
<!-- if true, then the string results of this sensor will not be used by the natural language parser -->
<xsd:element minOccurs="0" name="delimiter" type="xsd:string" />
<!-- the character(s) used to split the result into subcolumns -->
<xsd:element minOccurs="0" name="subcolumns" type="sensor_subcolumn_list" />
<xsd:element minOccurs="0" name="creation_time" type="xsd:string" />
<!-- When this was created in the database -->
<xsd:element minOccurs="0" name="modification_time" type="xsd:string" />
<!-- Last time it was modified -->
<xsd:element minOccurs="0" name="last_modified_by" type="xsd:string" />
<!-- name of the user who last modified or created this -->
<xsd:element minOccurs="0" name="string_hints" type="string_hint_list" />
<!-- define initial strings to be hashed and added to the string cache for this sensor. -->
<xsd:element minOccurs="0" name="preview_sensor_flag" type="xsd:int" />
<!-- creates/acquires a preview sensor -->
<xsd:element minOccurs="0" name="metadata" type="metadata_list" />
<xsd:element minOccurs="0" name="hidden_flag" type="xsd:int" />
<xsd:element minOccurs="0" name="deleted_flag" type="xsd:int" />
<xsd:element minOccurs="0" name="cache_row_id" type="xsd:int" />
<!-- ID used as a unqiue identifier in the response cache.
This is a regular Python object.
Attributes
----------
creation_time : :obj:`STR`
* Simple attribute that holds a python internal object type.
modification_time : :obj:`STR`
* Simple attribute that holds a python internal object type.
last_modified_by : :obj:`STR`
* Simple attribute that holds a python internal object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="audit_data">
<xsd:sequence>
<xsd:element minOccurs="0" name="creation_time" type="xsd:string" />
<!-- When this was created in the database -->
<xsd:element minOccurs="0" name="modification_time" type="xsd:string" />
<!-- Last time it was modified -->
<xsd:element minOccurs="0" name="last_modified_by" type="xsd:string" />
<!-- name of the user who last modified or created this -->
</xsd:sequence>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "audit_data"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self.creation_time = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.modification_time = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.last_modified_by = None
"""Simple property that should contain a python object type :obj:`STR`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
self._SIMPLE["creation_time"] = STR
self._SIMPLE["modification_time"] = STR
self._SIMPLE["last_modified_by"] = STR
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.BasicObject.__init__(self, **kwargs)
[docs]class Filter(models.BasicObject):
"""Tanium SOAP XML element ``filter`` Python object.
This is a regular Python object.

Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="filter">
<xsd:all>
<xsd:element minOccurs="0" name="id" type="xsd:int" />
<xsd:element minOccurs="0" name="sensor" type="sensor" />
<!-- when a filter is applied to machines, the value(s) of this sensor are tested -->
<!--
The filter operator defines how the value(s) of the items being tested are compared against the value specified in the filter.
Available operators are:
HashMatch: the item passes if the hash of its value matches the filter value (this is the default)
RegexMatch: the item passes if its value matches the regular expression specified in the filter value
Less, Greater, LessEqual, GreaterEqual, Equal: the item passes if its value is Less, Greater, LessEqual, GreaterEqual, Equal to the filter value
-->
<xsd:element minOccurs="0" name="operator" type="xsd:string" />
<!--
The value_type specifies how the values are compared. This does not apply if the operator is HashMatch or RegexMatch. The default is the result type of the sensor.
String: standard lexicographical comparison (the default)
Version: values are expected to be version strings, e.g. 9.4.2 is less than 10.1.3
Numeric: numeric comparison, including decimal, floating point, and scientific notation
BESDate: values are expected to be valid BES date strings
IPAddress: values are expected to be IP addresses
WMIDate: values are expected to be valid WMI date strings
TimeDiff: values are expected to be an expression of an amount of time, e.g. "2 years, 3 months, 18 days, 4 hours, 22 minutes, and 3.67 seconds" or "4.2 hours" (numeric + "Y|MO|W|D|H|M|S" units)
DataSize: values are expected to be an expression of an amount of data, e.g. 125MB or 23K or 34.2Gig (numeric + B|K|M|G|T units)
NumericInteger: values are expected to be integer numeric values
-->
<xsd:element minOccurs="0" name="value_type" type="xsd:string" />
<xsd:element minOccurs="0" name="value" type="xsd:string" />
<!-- depending on the operator, this is the regular expression to match, the hash to match, or the value to compare against -->
<xsd:element minOccurs="0" name="not_flag" type="xsd:int" />
<!-- if set, negate the match -->
<xsd:element minOccurs="0" name="max_age_seconds" type="xsd:int" />
<!-- how old a sensor result can be before we consider it invalid, default is 0 which means to use the max age property of the sensor -->
<xsd:element minOccurs="0" name="ignore_case_flag" type="xsd:int" />
<!-- note that unlike most flags, this defaults to true which means case is ignored by default -->
<xsd:element minOccurs="0" name="all_values_flag" type="xsd:int" />
<!-- if set, a plural item passes the filter only if all of its values pass the filters, by default a plural item passes if any of its values passes -->
<!--
If subtring_flag is set then the substring of the item's value specified by substring_start and substring_length is tested instead of the item's value itself
-->
<xsd:element minOccurs="0" name="substring_flag" type="xsd:int" />
<xsd:element minOccurs="0" name="substring_start" type="xsd:int" />
<xsd:element minOccurs="0" name="substring_length" type="xsd:int" />
<!--
If delimiter is not empty, then the item's value is expected to be a list of values separated by the delimiter and the actual value tested will be the
"sub item" whose index is specified in the delimiter_index. This is intended to be used in conjunction with the sensor "sub columns" feature.
-->
<xsd:element minOccurs="0" name="delimiter" type="xsd:string" />
<!-- currently only a single character delimiter is supported -->
<xsd:element minOccurs="0" name="delimiter_index" type="xsd:int" />
<!--
Not Yet Implemented. The following tags are reserved for future use:
-->
<xsd:element minOccurs="0" name="utf8_flag" type="xsd:int" />
<!-- Not Yet Implemented (for UTF8 regular expressions and case sensitivity) -->
<xsd:element minOccurs="0" name="aggregation" type="xsd:string" />
<!-- Not Yet Implemented (Sum, Average, Minimum, Maximum, Count) -->
<xsd:element minOccurs="0" name="all_times_flag" type="xsd:int" />
<!-- Not Yet Implemented -->
<xsd:element minOccurs="0" name="start_time" type="xsd:string" />
<!-- Not Yet Implemented (format is yyyy-mm-ddThh:mm:ss, for example: 2012-07-24T12:31:00 ) -->
<xsd:element minOccurs="0" name="end_time" type="xsd:string" />
<!--
This is a regular Python object.

Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="group">
<xsd:all>
<!--
The membership of a group is calculated by testing each candidate item and either including it or excluding it from the group.
First, items are checked to see if they are a member of all of the sub_groups (if and_flag is set), or any of the subgroups (if and_flag is not set)
Second, items are checked to see if they pass all of the filters ( if and_flag is set), or any of the filters (if and_flag is not set)
If the not_flag is set the members of the group are all the items that would have normally been excluded.
Note that if no sub_groups are specified, all items are included, and if no filters are specified, all items are included, so an "empty" group means "All"
-->
<xsd:element minOccurs="0" name="id" type="xsd:int" />
<xsd:element minOccurs="0" name="name" type="xsd:string" />
<!-- note that this is optional, and by default Groups are anonymous. Also, if a group is referred to by name, the name must be unique -->
<xsd:element minOccurs="0" name="text" type="xsd:string" />
<!-- Text, if any, that this group represents. -->
<xsd:element minOccurs="0" name="and_flag" type="xsd:int" />
<xsd:element minOccurs="0" name="not_flag" type="xsd:int" />
<xsd:element minOccurs="0" name="type" type="xsd:int" />
<xsd:element minOccurs="0" name="sub_groups" type="group_list" />
<xsd:element minOccurs="0" name="filters" type="filter_list" />
<xsd:element minOccurs="0" name="source_id" type="xsd:int" />
<!-- source id of group for parameterized groups -->
<xsd:element minOccurs="0" name="parameters" type="parameter_list" />
<!-- List of parameters to substitute into the source group. -->
<!-- the following elements are not used at creation time... they are essentially "read-only" -->
<xsd:element minOccurs="0" name="deleted_flag" type="xsd:int" />
</xsd:all>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "group"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self.id = None
"""Simple property that should contain a python object type :obj:`int`."""
self.name = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.text = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.and_flag = None
"""Simple property that should contain a python object type :obj:`int`."""
self.not_flag = None
"""Simple property that should contain a python object type :obj:`int`."""
self.type = None
"""Simple property that should contain a python object type :obj:`int`."""
self.source_id = None
"""Simple property that should contain a python object type :obj:`int`."""
self.deleted_flag = None
"""Simple property that should contain a python object type :obj:`int`."""
self.sub_groups = None
"""Complex property that should contain a tanium_soul object type :obj:`GroupList`."""
self.filters = None
"""Complex property that should contain a tanium_soul object type :obj:`FilterList`."""
self.parameters = None
"""Complex property that should contain a tanium_soul object type :obj:`ParameterList`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
self._SIMPLE["id"] = int
self._SIMPLE["name"] = STR
self._SIMPLE["text"] = STR
self._SIMPLE["and_flag"] = int
self._SIMPLE["not_flag"] = int
self._SIMPLE["type"] = int
self._SIMPLE["source_id"] = int
self._SIMPLE["deleted_flag"] = int
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["sub_groups"] = GroupList
self._COMPLEX["filters"] = FilterList
self._COMPLEX["parameters"] = ParameterList
models.BasicObject.__init__(self, **kwargs)
[docs]class Select(models.BasicObject):
"""Tanium SOAP XML element ``select`` Python object.
This is a regular Python object.
Attributes
----------
sensor : :obj:`Sensor`
* Complex attribute that holds a tanium_soul object type.
filter : :obj:`Filter`
* Complex attribute that holds a tanium_soul object type.
group : :obj:`Group`
* Complex attribute that holds a tanium_soul object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="select">
<xsd:all>
<!--
selects can be filtered by a simple filter, or by a group, or both.
First, items are checked to see if they are a member of all of the sub_groups (if and_flag is set), or any of the sub_groups (if and_flag is not set)
Second, items are checked to see if they pass all of the filters ( if and_flag is set), or any of the filters (if and_flag is not set)
If the not_flag is set the members of the group are all the items that would have normally been excluded.
Note that if no subgroups are specified, all items are included, and if no filters are specified, all items are included
-->
<xsd:element minOccurs="0" name="sensor" type="sensor" />
<!-- the sensor whose values will be retrieved -->
<xsd:element minOccurs="0" name="filter" type="filter" />
<!-- Only values that pass this filter will be retrieved -->
<xsd:element minOccurs="0" name="group" type="group" />
<!-- Only values that are members of this group will be retrieved. -->
</xsd:all>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "select"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self.sensor = None
"""Complex property that should contain a tanium_soul object type :obj:`Sensor`."""
self.filter = None
"""Complex property that should contain a tanium_soul object type :obj:`Filter`."""
self.group = None
"""Complex property that should contain a tanium_soul object type :obj:`Group`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
# no simple properties defined for this object
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["sensor"] = Sensor
self._COMPLEX["filter"] = Filter
self._COMPLEX["group"] = Group
models.BasicObject.__init__(self, **kwargs)
[docs]class XmlError(models.BasicObject):
"""Tanium SOAP XML element ``xml_error`` Python object.
This is a regular Python object.
Attributes
----------
type : :obj:`STR`
* Simple attribute that holds a python internal object type.
exception : :obj:`STR`
* Simple attribute that holds a python internal object type.
error_context : :obj:`STR`
* Simple attribute that holds a python internal object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="xml_error">
<xsd:all>
<xsd:element minOccurs="0" name="type" type="xsd:string" />
<!-- type of object that generated an error -->
<xsd:element minOccurs="0" name="exception" type="xsd:string" />
<!-- the exception or failure that occurred -->
<xsd:element minOccurs="0" name="error_context" type="xsd:string" />
<!-- the xml being generated at the time of the failure -->
</xsd:all>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "xml_error"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self.type = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.exception = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.error_context = None
"""Simple property that should contain a python object type :obj:`STR`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
self._SIMPLE["type"] = STR
self._SIMPLE["exception"] = STR
self._SIMPLE["error_context"] = STR
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.BasicObject.__init__(self, **kwargs)
[docs]class CacheInfo(models.BasicObject):
"""Tanium SOAP XML element ``cache_info`` Python object.
This is a regular Python object.
Attributes
----------
cache_id : :obj:`int`
* Simple attribute that holds a python internal object type.
page_row_count : :obj:`int`
* Simple attribute that holds a python internal object type.
filtered_row_count : :obj:`int`
* Simple attribute that holds a python internal object type.
cache_row_count : :obj:`int`
* Simple attribute that holds a python internal object type.
expiration : :obj:`STR`
* Simple attribute that holds a python internal object type.
errors : :obj:`ErrorList`
* Complex attribute that holds a tanium_soul object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="cache_info">
<xsd:all>
<xsd:element minOccurs="0" name="cache_id" type="xsd:long" />
<!-- ID of the cache created by the request -->
<xsd:element minOccurs="0" name="page_row_count" type="xsd:int" />
<!-- Number of rows return in the curreng page -->
<xsd:element minOccurs="0" name="filtered_row_count" type="xsd:int" />
<!-- The total number of rows in this cache after filter/sort-->
<xsd:element minOccurs="0" name="cache_row_count" type="xsd:int" />
<!-- The total number of rows in this cache before filter/sort-->
<xsd:element minOccurs="0" name="expiration" type="xsd:string" />
<!-- The time that this cache will expire -->
<xsd:element minOccurs="0" name="errors" type="error_list" />
<!-- if there was a problem generating the XML errors will be listed here -->
</xsd:all>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "cache_info"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self.cache_id = None
"""Simple property that should contain a python object type :obj:`int`."""
self.page_row_count = None
"""Simple property that should contain a python object type :obj:`int`."""
self.filtered_row_count = None
"""Simple property that should contain a python object type :obj:`int`."""
self.cache_row_count = None
"""Simple property that should contain a python object type :obj:`int`."""
self.expiration = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.errors = None
"""Complex property that should contain a tanium_soul object type :obj:`ErrorList`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
self._SIMPLE["cache_id"] = int
self._SIMPLE["page_row_count"] = int
self._SIMPLE["filtered_row_count"] = int
self._SIMPLE["cache_row_count"] = int
self._SIMPLE["expiration"] = STR
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["errors"] = ErrorList
models.BasicObject.__init__(self, **kwargs)
[docs]class QuestionListInfo(models.BasicObject):
"""Tanium SOAP XML element ``question_list_info`` Python object.
This is a regular Python object.
Attributes
----------
highest_id : :obj:`int`
* Simple attribute that holds a python internal object type.
total_count : :obj:`int`
* Simple attribute that holds a python internal object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="question_list_info">
<xsd:all>
<xsd:element minOccurs="0" name="highest_id" type="xsd:int" />
<xsd:element minOccurs="0" name="total_count" type="xsd:int" />
</xsd:all>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "question_list_info"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self.highest_id = None
"""Simple property that should contain a python object type :obj:`int`."""
self.total_count = None
"""Simple property that should contain a python object type :obj:`int`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
self._SIMPLE["highest_id"] = int
self._SIMPLE["total_count"] = int
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.BasicObject.__init__(self, **kwargs)
[docs]class Question(models.BasicObject):
"""Tanium SOAP XML element ``question`` Python object.
This is a regular Python object.

Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="question">
<xsd:all>
<!--
A question object is a list of data to be retrieved (the "selects"), plus a group that defines the set of machines from which the data should be retrieved.
-->
<xsd:element minOccurs="0" name="id" type="xsd:int" />
<xsd:element minOccurs="0" name="selects" type="select_list" />
<!-- List of what data to retrieve -->
<xsd:element minOccurs="0" name="context_group" type="group" />
<!-- The context in which this question is asked, similar to management_rights_group but not tied to the user/session context, can be used to narrow the group of machines to retrieve data from -->
<xsd:element minOccurs="0" name="group" type="group" />
<!-- The group of machines to retrieve the data from -->
<xsd:element minOccurs="0" name="expire_seconds" type="xsd:int" />
<!-- how long from now before the question expires (default is 600) -->
<xsd:element minOccurs="0" name="skip_lock_flag" type="xsd:int" />
<!-- if set, clients will ignore the value of the skip_lock client setting. This should rarely, if ever, be enabled. -->
<!-- the following elements are not used at creation time... they are essentially "read-only" -->
<xsd:element minOccurs="0" name="expiration" type="xsd:string" />
<!-- the date and time of expiration (format is yyyy-mm-ddThh:mm:ss, for example: 2012-07-24T12:31:00 ) -->
<xsd:element minOccurs="0" name="is_expired" type="xsd:int" />
<!-- is the question expired, at the time it was retrieved -->
<xsd:element minOccurs="0" name="user" type="user" />
<!-- the user that issued this question. The question will only be answered by machines that were members of the user's management rights group when the question was issued -->
<xsd:element minOccurs="0" name="management_rights_group" type="group" />
<!-- The management rights group of the user at the time the question was issued. -->
<!-- the following elements are derived from the saved question, if this question object is an instance of a saved question -->
<xsd:element minOccurs="0" name="name" type="xsd:string" />
<xsd:element minOccurs="0" name="query_text" type="xsd:string" />
<!-- textual representation of the question -->
<xsd:element minOccurs="0" name="hidden_flag" type="xsd:int" />
<!-- if set, then this is an "internal" object that should not be shown to end users -->
<xsd:element minOccurs="0" name="action_tracking_flag" type="xsd:int" />
<!-- indicates that this question is intended to track action status history -->
<xsd:element minOccurs="0" name="force_computer_id_flag" type="xsd:int" />
<!-- force question to not be a counting question if only 1 select is present -->
<xsd:element minOccurs="0" name="saved_question" type="saved_question" />
<!-- saved question associated to question -->
<xsd:element minOccurs="0" name="cache_row_id" type="xsd:int" />
<!-- ID used as a unqiue identifier in the response cache. Refer to cache_id in options. -->
<!--
The following element is used to specify the order in which questions/saved_questions are merged
when using the GetMergedResultData command. All or none of the questions/saved_questions in the
object_list must specify an index, and if the index values are specified, they must be contiguous
and begin with 0 and not include any duplicate values.
-->
<xsd:element minOccurs="0" name="index" type="xsd:int" />
</xsd:all>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "question"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self.id = None
"""Simple property that should contain a python object type :obj:`int`."""
self.expire_seconds = None
"""Simple property that should contain a python object type :obj:`int`."""
self.skip_lock_flag = None
"""Simple property that should contain a python object type :obj:`int`."""
self.expiration = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.is_expired = None
"""Simple property that should contain a python object type :obj:`int`."""
self.name = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.query_text = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.hidden_flag = None
"""Simple property that should contain a python object type :obj:`int`."""
self.action_tracking_flag = None
"""Simple property that should contain a python object type :obj:`int`."""
self.force_computer_id_flag = None
"""Simple property that should contain a python object type :obj:`int`."""
self.cache_row_id = None
"""Simple property that should contain a python object type :obj:`int`."""
self.index = None
"""Simple property that should contain a python object type :obj:`int`."""
self.selects = None
"""Complex property that should contain a tanium_soul object type :obj:`SelectList`."""
self.context_group = None
"""Complex property that should contain a tanium_soul object type :obj:`Group`."""
self.group = None
"""Complex property that should contain a tanium_soul object type :obj:`Group`."""
self.user = None
"""Complex property that should contain a tanium_soul object type :obj:`User`."""
self.management_rights_group = None
"""Complex property that should contain a tanium_soul object type :obj:`Group`."""
self.saved_question = None
"""Complex property that should contain a tanium_soul object type :obj:`SavedQuestion`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
self._SIMPLE["id"] = int
self._SIMPLE["expire_seconds"] = int
self._SIMPLE["skip_lock_flag"] = int
self._SIMPLE["expiration"] = STR
self._SIMPLE["is_expired"] = int
self._SIMPLE["name"] = STR
self._SIMPLE["query_text"] = STR
self._SIMPLE["hidden_flag"] = int
self._SIMPLE["action_tracking_flag"] = int
self._SIMPLE["force_computer_id_flag"] = int
self._SIMPLE["cache_row_id"] = int
self._SIMPLE["index"] = int
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["selects"] = SelectList
self._COMPLEX["context_group"] = Group
self._COMPLEX["group"] = Group
self._COMPLEX["user"] = User
self._COMPLEX["management_rights_group"] = Group
self._COMPLEX["saved_question"] = SavedQuestion
models.BasicObject.__init__(self, **kwargs)
[docs]class PackageFileTemplate(models.BasicObject):
"""Tanium SOAP XML element ``package_file_template`` Python object.
This is a regular Python object.
Attributes
----------
hash : :obj:`STR`
* Simple attribute that holds a python internal object type.
name : :obj:`STR`
* Simple attribute that holds a python internal object type.
source : :obj:`STR`
* Simple attribute that holds a python internal object type.
download_seconds : :obj:`int`
* Simple attribute that holds a python internal object type.
Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="package_file_template">
<xsd:all>
<xsd:element minOccurs="0" name="hash" type="xsd:string" />
<!-- The SHA-256 hash of the contents of the file -->
<xsd:element minOccurs="0" name="name" type="xsd:string" />
<xsd:element minOccurs="0" name="source" type="xsd:string" />
<!-- Where to get the file from, usually a url or unc path -->
<xsd:element minOccurs="0" name="download_seconds" type="xsd:int" />
<!-- How frequently to check the source to see if there is a new version of the file -->
</xsd:all>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "package_file_template"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self.hash = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.name = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.source = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.download_seconds = None
"""Simple property that should contain a python object type :obj:`int`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
self._SIMPLE["hash"] = STR
self._SIMPLE["name"] = STR
self._SIMPLE["source"] = STR
self._SIMPLE["download_seconds"] = int
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
# no complex properties defined for this object
models.BasicObject.__init__(self, **kwargs)
[docs]class PackageFileStatus(models.BasicObject):
"""Tanium SOAP XML element ``package_file_status`` Python object.
This is a regular Python object.
Attributes
----------
server_id : :obj:`int`
* Simple attribute that holds a python internal object type.
server_name : :obj:`STR`
* Simple attribute that holds a python internal object type.
status : :obj:`int`
* Simple attribute that holds a python internal object type.
cache_status : :obj:`STR`
* Simple attribute that holds a python internal object type.
cache_message : :obj:`STR`
* Simple attribute that holds a python internal object type.
bytes_downloaded : :obj:`int`
* Simple attribute that holds a python internal object type.
bytes_total : :obj:`int`
* Simple attribute that holds a python internal object type.
download_start_time : :obj:`STR`
* Simple attribute that holds a python internal object type.
last_download_progress_time : :obj:`STR`
* Simple attribute that holds a python internal object type.

This is a regular Python object.

Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="package_file">
<xsd:all>
<xsd:element minOccurs="0" name="id" type="xsd:int" />
<xsd:element minOccurs="0" name="hash" type="xsd:string" />
<!-- The SHA-256 hash of the contents of the file -->
<xsd:element minOccurs="0" name="name" type="xsd:string" />
<xsd:element minOccurs="0" name="size" type="xsd:int" />
<xsd:element minOccurs="0" name="source" type="xsd:string" />
<!-- Where to get the file from, usually a url or unc path -->
<xsd:element minOccurs="0" name="download_seconds" type="xsd:int" />
<!-- How frequently to check the source to see if there is a new version of the file -->
<xsd:element minOccurs="0" name="trigger_download" type="xsd:int" />
<!-- Using the UpdateObject command, with the ID, and this set to 1 will trigger a re-download of this file into the cache. -->
<!-- the following elements are not used at creation time... they are essentially "read-only" -->
<!-- The availability of the file on the server. Expected values are:
CACHED
UNCACHED
[ a string begining with ERROR: ]
-->
<xsd:element minOccurs="0" name="cache_status" type="xsd:string" />
<!-- The download status of the file. Common values are:
0 - check cache_status
2 - in progress
4 - in progress
other number less than 100 - error
200 - complete (check cache_status)
4xx - HTTP client error
5xx - HTTP server error
1xxx - other error
-->
<xsd:element minOccurs="0" name="status" type="xsd:int" />
<xsd:element minOccurs="0" name="bytes_downloaded" type="xsd:int" />
<xsd:element minOccurs="0" name="bytes_total" type="xsd:int" />
<xsd:element minOccurs="0" name="download_start_time" type="xsd:string" />
<!-- the time download began -->
<xsd:element minOccurs="0" name="last_download_progress_time" type="xsd:string" />
<!-- the last time dowload progress changed -->
<xsd:element minOccurs="0" name="file_status" type="package_file_status_list" />
<!-- per server summary of the file status -->
<xsd:element minOccurs="0" name="deleted_flag" type="xsd:int" />
<!-- if set, then this package file has/will been marked as deleted -->
</xsd:all>
</xsd:complexType>
"""
CONSTANTS = [
# no constants defined for this object
]
"""Constant values extracted from WSDL (for reference)."""
_SOAP_TAG = "package_file"
"""XML tag to use when serializing/deserializing."""
[docs] def __init__(self, **kwargs):
"""Constructor."""
self.id = None
"""Simple property that should contain a python object type :obj:`int`."""
self.hash = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.name = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.size = None
"""Simple property that should contain a python object type :obj:`int`."""
self.source = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.download_seconds = None
"""Simple property that should contain a python object type :obj:`int`."""
self.trigger_download = None
"""Simple property that should contain a python object type :obj:`int`."""
self.cache_status = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.status = None
"""Simple property that should contain a python object type :obj:`int`."""
self.bytes_downloaded = None
"""Simple property that should contain a python object type :obj:`int`."""
self.bytes_total = None
"""Simple property that should contain a python object type :obj:`int`."""
self.download_start_time = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.last_download_progress_time = None
"""Simple property that should contain a python object type :obj:`STR`."""
self.deleted_flag = None
"""Simple property that should contain a python object type :obj:`int`."""
self.file_status = None
"""Complex property that should contain a tanium_soul object type :obj:`PackageFileStatusList`."""
self._SIMPLE = {}
"""Dict of simple properties that maps a class attribute to its expected type."""
self._SIMPLE["id"] = int
self._SIMPLE["hash"] = STR
self._SIMPLE["name"] = STR
self._SIMPLE["size"] = int
self._SIMPLE["source"] = STR
self._SIMPLE["download_seconds"] = int
self._SIMPLE["trigger_download"] = int
self._SIMPLE["cache_status"] = STR
self._SIMPLE["status"] = int
self._SIMPLE["bytes_downloaded"] = int
self._SIMPLE["bytes_total"] = int
self._SIMPLE["download_start_time"] = STR
self._SIMPLE["last_download_progress_time"] = STR
self._SIMPLE["deleted_flag"] = int
self._COMPLEX = {}
"""Dict of complex properties that maps a class attribute to its expected type."""
self._COMPLEX["file_status"] = PackageFileStatusList
models.BasicObject.__init__(self, **kwargs)
[docs]class PackageSpec(models.BasicObject):
"""Tanium SOAP XML element ``package_spec`` Python object.
This is a regular Python object.

Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="package_spec">
<xsd:all>
<!--
A package_spec object is a list of files to be distributed and a command to be executed. Typically referred to simply as a "package"
-->
<xsd:element minOccurs="0" name="id" type="xsd:long" />
<xsd:element minOccurs="0" name="name" type="xsd:string" />
<!-- it is possible to refer to an object by name, but if the name is not unique an error may be generated. -->
<xsd:element minOccurs="0" name="display_name" type="xsd:string" />
<!-- display name of package -->
<xsd:element minOccurs="0" name="files" type="package_file_list" />
<!-- List of files to distribute -->
<xsd:element minOccurs="0" name="file_templates" type="package_file_template_list" />
<!-- List of files to distribute where file is determined by parameter substitution -->
<xsd:element minOccurs="0" name="command" type="xsd:string" />
<!-- Command to be executed -->
<xsd:element minOccurs="0" name="command_timeout" type="xsd:int" />
<!-- Limit on how long the command can execute before it will be terminated -->
<xsd:element minOccurs="0" name="expire_seconds" type="xsd:int" />
<!-- This value is added to the command_timeout to determine how long the action will be active before it is considered expired -->
<xsd:element minOccurs="0" name="hidden_flag" type="xsd:int" />
<!-- if set, then this is an "internal" object that should not be shown to end users.
This normally defaults to false; however, if source_id is specified, it defaults to true. -->
<xsd:element minOccurs="0" name="signature" type="xsd:string" />
<!-- A value that will be verified if the server license requires signed content -->
<xsd:element minOccurs="0" name="source_id" type="xsd:int" />
<!-- the package id of the package into which the parameters are substituted -->
<xsd:element minOccurs="0" name="verify_group_id" type="xsd:int" />
<!-- deprecated, use verify_group -->
<xsd:element minOccurs="0" name="verify_group" type="group" />
<!-- use this to specify a verify group. this will create one if it doesn't exist -->
<xsd:element minOccurs="0" name="verify_expire_seconds" type="xsd:int" />
<xsd:element minOccurs="0" name="skip_lock_flag" type="xsd:int" />
<xsd:element minOccurs="0" name="parameters" type="parameter_list" />
<!-- List of parameters to substitute into the source package -->
<xsd:element minOccurs="0" name="parameter_definition" type="xsd:string" />
<xsd:element minOccurs="0" name="sensors" type="sensor_list" />
<!-- sensors associated with a particular package -->
<!-- following elements are not used at creation time... they are essentially "read-only" -->
<xsd:element minOccurs="0" name="creation_time" type="xsd:string" />
<!-- When this was created in the database -->
<xsd:element minOccurs="0" name="modification_time" type="xsd:string" />
<!-- Last time it was modified -->
<xsd:element minOccurs="0" name="last_modified_by" type="xsd:string" />
<!-- name of the user who last modified or created this -->
<xsd:element minOccurs="0" name="available_time" type="xsd:string" />
<!-- the date and time when all of the files became available -->
<xsd:element minOccurs="0" name="deleted_flag" type="xsd:int" />
<!-- if set, then this package has been marked as deleted -->
<xsd:element minOccurs="0" name="metadata" type="metadata_list" />
<xsd:element minOccurs="0" name="last_update" type="xsd:string" />
<!-- the date and time when this package was last updated -->
<xsd:element minOccurs="0" name="cache_row_id" type="xsd:int" />
<!-- ID used as a unqiue identifier in the response cache.
This is a regular Python object.

Notes
-----
WSDL documentation for this object:
<xsd:complexType xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="client_status">
<xsd:all>
<!--
A client_status object is details about a client at the last time it reported.
-->
<xsd:element minOccurs="0" name="host_name" type="xsd:string" />
<xsd:element minOccurs="0" name="computer_id" type="xsd:string" />
<xsd:element minOccurs="0" name="ipaddress_client" type="xsd:string" />
<xsd:element minOccurs="0" name="ipaddress_server" type="xsd:string" />
<xsd:element minOccurs="0" name="protocol_version" type="xsd:int" />
<xsd:element minOccurs="0" name="full_version" type="xsd:string" />
<xsd:element minOccurs="0" name="last_registration" type="xsd:string" />
<xsd:element minOccurs="0" name="send_state" type="xsd:string" />
<xsd:element minOccurs="0" name="receive_state" type="xsd:string" />
<xsd:element minOccurs="0" name="status" type="xsd:string" />
<xsd:element minOccurs="0" name="port_number" type="xsd:int" />
<xsd:element minOccurs="0" name="public_key_valid" type="xsd:int" />
<xsd:element minOccurs="0" name="cache_row_id" type="xsd:int" />
<!-- ID used as a unqiue identifier in the response cache.
This is a regular Python object.
Attributes
----------
id : :obj:`int`
* Simple attribute that holds a python internal object type.
name : :obj:`STR`
* Simple attribute that holds a python internal object type.
value : :obj:`STR`
* Simple attribute that holds a python internal object type.
default_value : :obj:`STR`
* Simple attribute that holds a python internal object type.
value_type : :obj:`STR`
* Simple attribute that holds a python internal object type.
setting_type : :obj:`STR`
* Simple attribute that holds a python internal object type.
hidden_flag : :obj:`int`